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

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import React from 'react';
+import { FlexStyle, LayoutChangeEvent, ShadowStyleIOS, StyleProp, TransformsStyle, ImageRequireSource, AccessibilityProps, ViewProps, ColorValue } from 'react-native';
+export declare type ResizeMode = 'contain' | 'cover' | 'stretch' | 'center';
+declare const resizeMode: {
+    readonly contain: "contain";
+    readonly cover: "cover";
+    readonly stretch: "stretch";
+    readonly center: "center";
+};
+export declare type Priority = 'low' | 'normal' | 'high';
+declare const priority: {
+    readonly low: "low";
+    readonly normal: "normal";
+    readonly high: "high";
+};
+declare type Cache = 'immutable' | 'web' | 'cacheOnly';
+declare const cacheControl: {
+    readonly immutable: "immutable";
+    readonly web: "web";
+    readonly cacheOnly: "cacheOnly";
+};
+export declare type Source = {
+    uri?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    priority?: Priority;
+    cache?: Cache;
+};
+export interface OnLoadEvent {
+    nativeEvent: {
+        width: number;
+        height: number;
+    };
+}
+export interface OnProgressEvent {
+    nativeEvent: {
+        loaded: number;
+        total: number;
+    };
+}
+export interface ImageStyle extends FlexStyle, TransformsStyle, ShadowStyleIOS {
+    backfaceVisibility?: 'visible' | 'hidden';
+    borderBottomLeftRadius?: number;
+    borderBottomRightRadius?: number;
+    backgroundColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    borderRadius?: number;
+    borderTopLeftRadius?: number;
+    borderTopRightRadius?: number;
+    overlayColor?: string;
+    opacity?: number;
+}
+export interface FastImageProps extends AccessibilityProps, ViewProps {
+    source?: Source | ImageRequireSource;
+    defaultSource?: ImageRequireSource;
+    resizeMode?: ResizeMode;
+    fallback?: boolean;
+    onLoadStart?(): void;
+    onProgress?(event: OnProgressEvent): void;
+    onLoad?(event: OnLoadEvent): void;
+    onError?(): void;
+    onLoadEnd?(): void;
+    /**
+     * onLayout function
+     *
+     * Invoked on mount and layout changes with
+     *
+     * {nativeEvent: { layout: {x, y, width, height}}}.
+     */
+    onLayout?: (event: LayoutChangeEvent) => void;
+    /**
+     *
+     * Style
+     */
+    style?: StyleProp<ImageStyle>;
+    /**
+     * TintColor
+     *
+     * If supplied, changes the color of all the non-transparent pixels to the given color.
+     */
+    tintColor?: ColorValue;
+    /**
+     * A unique identifier for this element to be used in UI Automation testing scripts.
+     */
+    testID?: string;
+    /**
+     * Render children within the image.
+     */
+    children?: React.ReactNode;
+}
+export interface FastImageStaticProperties {
+    resizeMode: typeof resizeMode;
+    priority: typeof priority;
+    cacheControl: typeof cacheControl;
+    preload: (sources: Source[]) => void;
+    clearMemoryCache: () => Promise<void>;
+    clearDiskCache: () => Promise<void>;
+}
+declare const FastImage: React.ComponentType<FastImageProps> & FastImageStaticProperties;
+export default FastImage;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,137 @@
+import _extends from '@babel/runtime/helpers/extends';
+import React, { forwardRef, memo } from 'react';
+import { NativeModules, StyleSheet, requireNativeComponent, Image, View, Platform } from 'react-native';
+
+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 (Platform.OS === 'android') {
+    // Android receives a URI string, and resolves into a Drawable using RN's methods.
+    const resolved = 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 = Image.resolveAssetSource(cleanedSource);
+    return /*#__PURE__*/React.createElement(View, {
+      style: [styles.imageContainer, style],
+      ref: forwardedRef
+    }, /*#__PURE__*/React.createElement(Image, _extends({}, props, {
+      style: [StyleSheet.absoluteFill, {
+        tintColor
+      }],
+      source: resolvedSource,
+      defaultSource: defaultSource,
+      onLoadStart: onLoadStart,
+      onProgress: onProgress,
+      onLoad: onLoad,
+      onError: onError,
+      onLoadEnd: onLoadEnd,
+      resizeMode: resizeMode
+    })), children);
+  }
+
+  const resolvedSource = Image.resolveAssetSource(source);
+  const resolvedDefaultSource = resolveDefaultSource(defaultSource);
+  return /*#__PURE__*/React.createElement(View, {
+    style: [styles.imageContainer, style],
+    ref: forwardedRef
+  }, /*#__PURE__*/React.createElement(FastImageView, _extends({}, props, {
+    tintColor: tintColor,
+    style: StyleSheet.absoluteFill,
+    source: resolvedSource,
+    defaultSource: resolvedDefaultSource,
+    onFastImageLoadStart: onLoadStart,
+    onFastImageProgress: onProgress,
+    onFastImageLoad: onLoad,
+    onFastImageError: onError,
+    onFastImageLoadEnd: onLoadEnd,
+    resizeMode: resizeMode
+  })), children);
+}
+
+const FastImageMemo = /*#__PURE__*/memo(FastImageBase);
+const FastImageComponent = /*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/React.createElement(FastImageMemo, _extends({
+  forwardedRef: ref
+}, props)));
+FastImageComponent.displayName = 'FastImage';
+const FastImage = FastImageComponent;
+FastImage.resizeMode = resizeMode;
+FastImage.cacheControl = cacheControl;
+FastImage.priority = priority;
+
+FastImage.preload = sources => NativeModules.FastImageView.preload(sources);
+
+FastImage.clearMemoryCache = () => NativeModules.FastImageView.clearMemoryCache();
+
+FastImage.clearDiskCache = () => NativeModules.FastImageView.clearDiskCache();
+
+const styles = StyleSheet.create({
+  imageContainer: {
+    overflow: 'hidden'
+  }
+}); // Types of requireNativeComponent are not correct.
+
+const FastImageView = requireNativeComponent('FastImageView', FastImage, {
+  nativeOnly: {
+    onFastImageLoadStart: true,
+    onFastImageProgress: true,
+    onFastImageLoad: true,
+    onFastImageError: true,
+    onFastImageLoadEnd: true
+  }
+});
+
+export default FastImage;

package/dist/index.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>;
+}

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.tsx"],"names":[],"mappings":""}

package/ios/FastImage/FFFastImageSource.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+typedef NS_ENUM(NSInteger, FFFPriority) {
+    FFFPriorityLow,
+    FFFPriorityNormal,
+    FFFPriorityHigh
+};
+
+typedef NS_ENUM(NSInteger, FFFCacheControl) {
+    FFFCacheControlImmutable,
+    FFFCacheControlWeb,
+    FFFCacheControlCacheOnly
+};
+
+// Object containing an image uri and metadata.
+@interface FFFastImageSource : NSObject
+
+// uri for image, or base64
+@property (nonatomic) NSURL* url;
+// priority for image request
+@property (nonatomic) FFFPriority priority;
+// headers for the image request
+@property (nonatomic) NSDictionary *headers;
+// cache control mode
+@property (nonatomic) FFFCacheControl cacheControl;
+
+- (instancetype)initWithURL:(NSURL *)url
+                   priority:(FFFPriority)priority
+                    headers:(NSDictionary *)headers
+               cacheControl:(FFFCacheControl)cacheControl;
+
+@end

package/ios/FastImage/FFFastImageSource.m

@@ -0,0 +1,20 @@
+#import "FFFastImageSource.h"
+
+@implementation FFFastImageSource
+
+- (instancetype)initWithURL:(NSURL *)url
+                   priority:(FFFPriority)priority
+                    headers:(NSDictionary *)headers
+               cacheControl:(FFFCacheControl)cacheControl
+{
+    self = [super init];
+    if (self) {
+        _url = url;
+        _priority = priority;
+        _headers = headers;
+        _cacheControl = cacheControl;
+    }
+    return self;
+}
+
+@end

package/ios/FastImage/FFFastImageView.h

@@ -0,0 +1,24 @@
+#import <UIKit/UIKit.h>
+
+#import <SDWebImage/SDAnimatedImageView+WebCache.h>
+#import <SDWebImage/SDWebImageDownloader.h>
+
+#import <React/RCTComponent.h>
+#import <React/RCTResizeMode.h>
+
+#import "FFFastImageSource.h"
+
+@interface FFFastImageView : SDAnimatedImageView
+
+@property (nonatomic, copy) RCTDirectEventBlock onFastImageLoadStart;
+@property (nonatomic, copy) RCTDirectEventBlock onFastImageProgress;
+@property (nonatomic, copy) RCTDirectEventBlock onFastImageError;
+@property (nonatomic, copy) RCTDirectEventBlock onFastImageLoad;
+@property (nonatomic, copy) RCTDirectEventBlock onFastImageLoadEnd;
+@property (nonatomic, assign) RCTResizeMode resizeMode;
+@property (nonatomic, strong) FFFastImageSource *source;
+@property (nonatomic, strong) UIImage *defaultSource;
+@property (nonatomic, strong) UIColor *imageColor;
+
+@end
+

package/ios/FastImage/FFFastImageView.m

@@ -0,0 +1,244 @@
+#import "FFFastImageView.h"
+#import <SDWebImage/UIImage+MultiFormat.h>
+#import <SDWebImage/UIView+WebCache.h>
+
+@interface FFFastImageView ()
+
+@property(nonatomic, assign) BOOL hasSentOnLoadStart;
+@property(nonatomic, assign) BOOL hasCompleted;
+@property(nonatomic, assign) BOOL hasErrored;
+// Whether the latest change of props requires the image to be reloaded
+@property(nonatomic, assign) BOOL needsReload;
+
+@property(nonatomic, strong) NSDictionary* onLoadEvent;
+
+@end
+
+@implementation FFFastImageView
+
+- (id) init {
+    self = [super init];
+    self.resizeMode = RCTResizeModeCover;
+    self.clipsToBounds = YES;
+    return self;
+}
+
+- (void) setResizeMode: (RCTResizeMode)resizeMode {
+    if (_resizeMode != resizeMode) {
+        _resizeMode = resizeMode;
+        self.contentMode = (UIViewContentMode) resizeMode;
+    }
+}
+
+- (void) setOnFastImageLoadEnd: (RCTDirectEventBlock)onFastImageLoadEnd {
+    _onFastImageLoadEnd = onFastImageLoadEnd;
+    if (self.hasCompleted) {
+        _onFastImageLoadEnd(@{});
+    }
+}
+
+- (void) setOnFastImageLoad: (RCTDirectEventBlock)onFastImageLoad {
+    _onFastImageLoad = onFastImageLoad;
+    if (self.hasCompleted) {
+        _onFastImageLoad(self.onLoadEvent);
+    }
+}
+
+- (void) setOnFastImageError: (RCTDirectEventBlock)onFastImageError {
+    _onFastImageError = onFastImageError;
+    if (self.hasErrored) {
+        _onFastImageError(@{});
+    }
+}
+
+- (void) setOnFastImageLoadStart: (RCTDirectEventBlock)onFastImageLoadStart {
+    if (_source && !self.hasSentOnLoadStart) {
+        _onFastImageLoadStart = onFastImageLoadStart;
+        onFastImageLoadStart(@{});
+        self.hasSentOnLoadStart = YES;
+    } else {
+        _onFastImageLoadStart = onFastImageLoadStart;
+        self.hasSentOnLoadStart = NO;
+    }
+}
+
+- (void) setImageColor: (UIColor*)imageColor {
+    if (imageColor != nil) {
+        _imageColor = imageColor;
+        if (super.image) {
+            super.image = [self makeImage: super.image withTint: self.imageColor];
+        }
+    }
+}
+
+- (UIImage*) makeImage: (UIImage*)image withTint: (UIColor*)color {
+    UIImage* newImage = [image imageWithRenderingMode: UIImageRenderingModeAlwaysTemplate];
+    UIGraphicsBeginImageContextWithOptions(image.size, NO, newImage.scale);
+    [color set];
+    [newImage drawInRect: CGRectMake(0, 0, image.size.width, newImage.size.height)];
+    newImage = UIGraphicsGetImageFromCurrentImageContext();
+    UIGraphicsEndImageContext();
+    return newImage;
+}
+
+- (void) setImage: (UIImage*)image {
+    if (self.imageColor != nil) {
+        super.image = [self makeImage: image withTint: self.imageColor];
+    } else {
+        super.image = image;
+    }
+}
+
+- (void) sendOnLoad: (UIImage*)image {
+    self.onLoadEvent = @{
+            @"width": [NSNumber numberWithDouble: image.size.width],
+            @"height": [NSNumber numberWithDouble: image.size.height]
+    };
+    if (self.onFastImageLoad) {
+        self.onFastImageLoad(self.onLoadEvent);
+    }
+}
+
+- (void) setSource: (FFFastImageSource*)source {
+    if (_source != source) {
+        _source = source;
+        _needsReload = YES;
+    }
+}
+
+- (void) setDefaultSource: (UIImage*)defaultSource {
+    if (_defaultSource != defaultSource) {
+        _defaultSource = defaultSource;
+        _needsReload = YES;
+    }
+}
+
+- (void) didSetProps: (NSArray<NSString*>*)changedProps {
+    if (_needsReload) {
+        [self reloadImage];
+    }
+}
+
+- (void) reloadImage {
+    _needsReload = NO;
+
+    if (_source) {
+        // Load base64 images.
+        NSString* url = [_source.url absoluteString];
+        if (url && [url hasPrefix: @"data:image"]) {
+            if (self.onFastImageLoadStart) {
+                self.onFastImageLoadStart(@{});
+                self.hasSentOnLoadStart = YES;
+            } else {
+                self.hasSentOnLoadStart = NO;
+            }
+            // Use SDWebImage API to support external format like WebP images
+            UIImage* image = [UIImage sd_imageWithData: [NSData dataWithContentsOfURL: _source.url]];
+            [self setImage: image];
+            if (self.onFastImageProgress) {
+                self.onFastImageProgress(@{
+                        @"loaded": @(1),
+                        @"total": @(1)
+                });
+            }
+            self.hasCompleted = YES;
+            [self sendOnLoad: image];
+
+            if (self.onFastImageLoadEnd) {
+                self.onFastImageLoadEnd(@{});
+            }
+            return;
+        }
+
+        // Set headers.
+        NSDictionary* headers = _source.headers;
+        SDWebImageDownloaderRequestModifier* requestModifier = [SDWebImageDownloaderRequestModifier requestModifierWithBlock: ^NSURLRequest* _Nullable (NSURLRequest* _Nonnull request) {
+            NSMutableURLRequest* mutableRequest = [request mutableCopy];
+            for (NSString* header in headers) {
+                NSString* value = headers[header];
+                [mutableRequest setValue: value forHTTPHeaderField: header];
+            }
+            return [mutableRequest copy];
+        }];
+        SDWebImageContext* context = @{SDWebImageContextDownloadRequestModifier: requestModifier};
+
+        // Set priority.
+        SDWebImageOptions options = SDWebImageRetryFailed | SDWebImageHandleCookies;
+        switch (_source.priority) {
+            case FFFPriorityLow:
+                options |= SDWebImageLowPriority;
+                break;
+            case FFFPriorityNormal:
+                // Priority is normal by default.
+                break;
+            case FFFPriorityHigh:
+                options |= SDWebImageHighPriority;
+                break;
+        }
+
+        switch (_source.cacheControl) {
+            case FFFCacheControlWeb:
+                options |= SDWebImageRefreshCached;
+                break;
+            case FFFCacheControlCacheOnly:
+                options |= SDWebImageFromCacheOnly;
+                break;
+            case FFFCacheControlImmutable:
+                break;
+        }
+
+        if (self.onFastImageLoadStart) {
+            self.onFastImageLoadStart(@{});
+            self.hasSentOnLoadStart = YES;
+        } else {
+            self.hasSentOnLoadStart = NO;
+        }
+        self.hasCompleted = NO;
+        self.hasErrored = NO;
+
+        [self downloadImage: _source options: options context: context];
+    } else if (_defaultSource) {
+        [self setImage: _defaultSource];
+    }
+}
+
+- (void) downloadImage: (FFFastImageSource*)source options: (SDWebImageOptions)options context: (SDWebImageContext*)context {
+    __weak typeof(self) weakSelf = self; // Always use a weak reference to self in blocks
+    [self sd_setImageWithURL: _source.url
+            placeholderImage: _defaultSource
+                     options: options
+                     context: context
+                    progress: ^(NSInteger receivedSize, NSInteger expectedSize, NSURL* _Nullable targetURL) {
+                        if (weakSelf.onFastImageProgress) {
+                            weakSelf.onFastImageProgress(@{
+                                    @"loaded": @(receivedSize),
+                                    @"total": @(expectedSize)
+                            });
+                        }
+                    } completed: ^(UIImage* _Nullable image,
+                    NSError* _Nullable error,
+                    SDImageCacheType cacheType,
+                    NSURL* _Nullable imageURL) {
+                if (error) {
+                    weakSelf.hasErrored = YES;
+                    if (weakSelf.onFastImageError) {
+                        weakSelf.onFastImageError(@{});
+                    }
+                    if (weakSelf.onFastImageLoadEnd) {
+                        weakSelf.onFastImageLoadEnd(@{});
+                    }
+                } else {
+                    weakSelf.hasCompleted = YES;
+                    [weakSelf sendOnLoad: image];
+                    if (weakSelf.onFastImageLoadEnd) {
+                        weakSelf.onFastImageLoadEnd(@{});
+                    }
+                }
+            }];
+}
+
+- (void) dealloc {
+    [self sd_cancelCurrentImageLoad];
+}
+
+@end

package/ios/FastImage/FFFastImageViewManager.h

@@ -0,0 +1,5 @@
+#import <React/RCTViewManager.h>
+
+@interface FFFastImageViewManager : RCTViewManager
+
+@end