@momo-kits/native-kits 0.0.1-beta.5 → 0.89.1-2

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDImageCacheConfig.h

@@ -1,153 +0,0 @@
-/*
- * This file is part of the SDWebImage package.
- * (c) Olivier Poitrey <rs@dailymotion.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-#import <Foundation/Foundation.h>
-#import "SDWebImageCompat.h"
-
-/// Image Cache Expire Type
-typedef NS_ENUM(NSUInteger, SDImageCacheConfigExpireType) {
-    /**
-     * When the image cache is accessed it will update this value
-     */
-    SDImageCacheConfigExpireTypeAccessDate,
-    /**
-     * When the image cache is created or modified it will update this value (Default)
-     */
-    SDImageCacheConfigExpireTypeModificationDate,
-    /**
-     * When the image cache is created it will update this value
-     */
-    SDImageCacheConfigExpireTypeCreationDate,
-    /**
-     * When the image cache is created, modified, renamed, file attribute updated (like permission, xattr)  it will update this value
-     */
-    SDImageCacheConfigExpireTypeChangeDate,
-};
-
-/**
- The class contains all the config for image cache
- @note This class conform to NSCopying, make sure to add the property in `copyWithZone:` as well.
- */
-@interface SDImageCacheConfig : NSObject <NSCopying>
-
-/**
- Gets the default cache config used for shared instance or initialization when it does not provide any cache config. Such as `SDImageCache.sharedImageCache`.
- @note You can modify the property on default cache config, which can be used for later created cache instance. The already created cache instance does not get affected.
- */
-@property (nonatomic, class, readonly, nonnull) SDImageCacheConfig *defaultCacheConfig;
-
-/**
- * Whether or not to disable iCloud backup
- * Defaults to YES.
- */
-@property (assign, nonatomic) BOOL shouldDisableiCloud;
-
-/**
- * Whether or not to use memory cache
- * @note When the memory cache is disabled, the weak memory cache will also be disabled.
- * Defaults to YES.
- */
-@property (assign, nonatomic) BOOL shouldCacheImagesInMemory;
-
-/*
- * The option to control weak memory cache for images. When enable, `SDImageCache`'s memory cache will use a weak maptable to store the image at the same time when it stored to memory, and get removed at the same time.
- * However when memory warning is triggered, since the weak maptable does not hold a strong reference to image instance, even when the memory cache itself is purged, some images which are held strongly by UIImageViews or other live instances can be recovered again, to avoid later re-query from disk cache or network. This may be helpful for the case, for example, when app enter background and memory is purged, cause cell flashing after re-enter foreground.
- * When enabling this option, we will sync back the image from weak maptable to strong cache during next time top level `sd_setImage` function call.
- * Defaults to NO (YES before 5.12.0 version). You can change this option dynamically.
- */
-@property (assign, nonatomic) BOOL shouldUseWeakMemoryCache;
-
-/**
- * Whether or not to remove the expired disk data when application entering the background. (Not works for macOS)
- * Defaults to YES.
- */
-@property (assign, nonatomic) BOOL shouldRemoveExpiredDataWhenEnterBackground;
-
-/**
- * Whether or not to remove the expired disk data when application been terminated. This operation is processed in sync to ensure clean up.
- * Defaults to YES.
- */
-@property (assign, nonatomic) BOOL shouldRemoveExpiredDataWhenTerminate;
-
-/**
- * The reading options while reading cache from disk.
- * Defaults to 0. You can set this to `NSDataReadingMappedIfSafe` to improve performance.
- */
-@property (assign, nonatomic) NSDataReadingOptions diskCacheReadingOptions;
-
-/**
- * The writing options while writing cache to disk.
- * Defaults to `NSDataWritingAtomic`. You can set this to `NSDataWritingWithoutOverwriting` to prevent overwriting an existing file.
- */
-@property (assign, nonatomic) NSDataWritingOptions diskCacheWritingOptions;
-
-/**
- * The maximum length of time to keep an image in the disk cache, in seconds.
- * Setting this to a negative value means no expiring.
- * Setting this to zero means that all cached files would be removed when do expiration check.
- * Defaults to 1 week.
- */
-@property (assign, nonatomic) NSTimeInterval maxDiskAge;
-
-/**
- * The maximum size of the disk cache, in bytes.
- * Defaults to 0. Which means there is no cache size limit.
- */
-@property (assign, nonatomic) NSUInteger maxDiskSize;
-
-/**
- * The maximum "total cost" of the in-memory image cache. The cost function is the bytes size held in memory.
- * @note The memory cost is bytes size in memory, but not simple pixels count. For common ARGB8888 image, one pixel is 4 bytes (32 bits).
- * Defaults to 0. Which means there is no memory cost limit.
- */
-@property (assign, nonatomic) NSUInteger maxMemoryCost;
-
-/**
- * The maximum number of objects in-memory image cache should hold.
- * Defaults to 0. Which means there is no memory count limit.
- */
-@property (assign, nonatomic) NSUInteger maxMemoryCount;
-
-/*
- * The attribute which the clear cache will be checked against when clearing the disk cache
- * Default is Modified Date
- */
-@property (assign, nonatomic) SDImageCacheConfigExpireType diskCacheExpireType;
-
-/**
- * The custom file manager for disk cache. Pass nil to let disk cache choose the proper file manager.
- * Defaults to nil.
- * @note This value does not support dynamic changes. Which means further modification on this value after cache initialized has no effect.
- * @note Since `NSFileManager` does not support `NSCopying`. We just pass this by reference during copying. So it's not recommend to set this value on `defaultCacheConfig`.
- */
-@property (strong, nonatomic, nullable) NSFileManager *fileManager;
-
-/**
- * The dispatch queue attr for ioQueue. You can config the QoS and concurrent/serial to internal IO queue. The ioQueue is used by SDImageCache to access read/write for disk data.
- * Defaults we use `DISPATCH_QUEUE_SERIAL`(NULL), to use serial dispatch queue to ensure single access for disk data. It's safe but may be slow.
- * @note You can override this to use `DISPATCH_QUEUE_CONCURRENT`, use concurrent queue.
- * @warning **MAKE SURE** to keep `diskCacheWritingOptions` to use `NSDataWritingAtomic`, or concurrent queue may cause corrupted disk data (because multiple threads read/write same file without atomic is not IO-safe).
- * @note This value does not support dynamic changes. Which means further modification on this value after cache initialized has no effect.
- */
-@property (strong, nonatomic, nullable) dispatch_queue_attr_t ioQueueAttributes;
-
-/**
- * The custom memory cache class. Provided class instance must conform to `SDMemoryCache` protocol to allow usage.
- * Defaults to built-in `SDMemoryCache` class.
- * @note This value does not support dynamic changes. Which means further modification on this value after cache initialized has no effect.
- */
-@property (assign, nonatomic, nonnull) Class memoryCacheClass;
-
-/**
- * The custom disk cache class. Provided class instance must conform to `SDDiskCache` protocol to allow usage.
- * Defaults to built-in `SDDiskCache` class.
- * @note This value does not support dynamic changes. Which means further modification on this value after cache initialized has no effect.
- */
-@property (assign ,nonatomic, nonnull) Class diskCacheClass;
-
-@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDImageCacheConfig.m

@@ -1,68 +0,0 @@
-/*
- * This file is part of the SDWebImage package.
- * (c) Olivier Poitrey <rs@dailymotion.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-#import "SDImageCacheConfig.h"
-#import "SDMemoryCache.h"
-#import "SDDiskCache.h"
-
-static SDImageCacheConfig *_defaultCacheConfig;
-static const NSInteger kDefaultCacheMaxDiskAge = 60 * 60 * 24 * 7; // 1 week
-
-@implementation SDImageCacheConfig
-
-+ (SDImageCacheConfig *)defaultCacheConfig {
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-        _defaultCacheConfig = [SDImageCacheConfig new];
-    });
-    return _defaultCacheConfig;
-}
-
-- (instancetype)init {
-    if (self = [super init]) {
-        _shouldDisableiCloud = YES;
-        _shouldCacheImagesInMemory = YES;
-        _shouldUseWeakMemoryCache = NO;
-        _shouldRemoveExpiredDataWhenEnterBackground = YES;
-        _shouldRemoveExpiredDataWhenTerminate = YES;
-        _diskCacheReadingOptions = 0;
-        _diskCacheWritingOptions = NSDataWritingAtomic;
-        _maxDiskAge = kDefaultCacheMaxDiskAge;
-        _maxDiskSize = 0;
-        _diskCacheExpireType = SDImageCacheConfigExpireTypeModificationDate;
-        _fileManager = nil;
-        _ioQueueAttributes = DISPATCH_QUEUE_SERIAL; // NULL
-        _memoryCacheClass = [SDMemoryCache class];
-        _diskCacheClass = [SDDiskCache class];
-    }
-    return self;
-}
-
-- (id)copyWithZone:(NSZone *)zone {
-    SDImageCacheConfig *config = [[[self class] allocWithZone:zone] init];
-    config.shouldDisableiCloud = self.shouldDisableiCloud;
-    config.shouldCacheImagesInMemory = self.shouldCacheImagesInMemory;
-    config.shouldUseWeakMemoryCache = self.shouldUseWeakMemoryCache;
-    config.shouldRemoveExpiredDataWhenEnterBackground = self.shouldRemoveExpiredDataWhenEnterBackground;
-    config.shouldRemoveExpiredDataWhenTerminate = self.shouldRemoveExpiredDataWhenTerminate;
-    config.diskCacheReadingOptions = self.diskCacheReadingOptions;
-    config.diskCacheWritingOptions = self.diskCacheWritingOptions;
-    config.maxDiskAge = self.maxDiskAge;
-    config.maxDiskSize = self.maxDiskSize;
-    config.maxMemoryCost = self.maxMemoryCost;
-    config.maxMemoryCount = self.maxMemoryCount;
-    config.diskCacheExpireType = self.diskCacheExpireType;
-    config.fileManager = self.fileManager; // NSFileManager does not conform to NSCopying, just pass the reference
-    config.ioQueueAttributes = self.ioQueueAttributes; // Pass the reference
-    config.memoryCacheClass = self.memoryCacheClass;
-    config.diskCacheClass = self.diskCacheClass;
-    
-    return config;
-}
-
-@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDImageCacheDefine.h

@@ -1,156 +0,0 @@
-/*
- * This file is part of the SDWebImage package.
- * (c) Olivier Poitrey <rs@dailymotion.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-#import <Foundation/Foundation.h>
-#import "SDWebImageCompat.h"
-#import "SDWebImageOperation.h"
-#import "SDWebImageDefine.h"
-#import "SDImageCoder.h"
-
-/// Image Cache Type
-typedef NS_ENUM(NSInteger, SDImageCacheType) {
-    /**
-     * For query and contains op in response, means the image isn't available in the image cache
-     * For op in request, this type is not available and take no effect.
-     */
-    SDImageCacheTypeNone,
-    /**
-     * For query and contains op in response, means the image was obtained from the disk cache.
-     * For op in request, means process only disk cache.
-     */
-    SDImageCacheTypeDisk,
-    /**
-     * For query and contains op in response, means the image was obtained from the memory cache.
-     * For op in request, means process only memory cache.
-     */
-    SDImageCacheTypeMemory,
-    /**
-     * For query and contains op in response, this type is not available and take no effect.
-     * For op in request, means process both memory cache and disk cache.
-     */
-    SDImageCacheTypeAll
-};
-
-typedef void(^SDImageCacheCheckCompletionBlock)(BOOL isInCache);
-typedef void(^SDImageCacheQueryDataCompletionBlock)(NSData * _Nullable data);
-typedef void(^SDImageCacheCalculateSizeBlock)(NSUInteger fileCount, NSUInteger totalSize);
-typedef NSString * _Nullable (^SDImageCacheAdditionalCachePathBlock)(NSString * _Nonnull key);
-typedef void(^SDImageCacheQueryCompletionBlock)(UIImage * _Nullable image, NSData * _Nullable data, SDImageCacheType cacheType);
-typedef void(^SDImageCacheContainsCompletionBlock)(SDImageCacheType containsCacheType);
-
-/**
- This is the built-in decoding process for image query from cache.
- @note If you want to implement your custom loader with `queryImageForKey:options:context:completion:` API, but also want to keep compatible with SDWebImage's behavior, you'd better use this to produce image.
- 
- @param imageData The image data from the cache. Should not be nil
- @param cacheKey The image cache key from the input. Should not be nil
- @param options The options arg from the input
- @param context The context arg from the input
- @return The decoded image for current image data query from cache
- */
-FOUNDATION_EXPORT UIImage * _Nullable SDImageCacheDecodeImageData(NSData * _Nonnull imageData, NSString * _Nonnull cacheKey, SDWebImageOptions options, SDWebImageContext * _Nullable context);
-
-/// Get the decode options from the loading context options and cache key. This is the built-in translate between the web loading part to the decoding part (which does not depends on).
-/// @param context The context arg from the input
-/// @param options The options arg from the input
-/// @param cacheKey The image cache key from the input. Should not be nil
-FOUNDATION_EXPORT SDImageCoderOptions * _Nonnull SDGetDecodeOptionsFromContext(SDWebImageContext * _Nullable context, SDWebImageOptions options, NSString * _Nonnull cacheKey);
-
-/// Set the decode options to the loading context options. This is the built-in translate between the web loading part from the decoding part (which does not depends on).
-/// @param mutableContext The context arg to override
-/// @param mutableOptions The options arg to override
-/// @param decodeOptions The image decoding options
-FOUNDATION_EXPORT void SDSetDecodeOptionsToContext(SDWebImageMutableContext * _Nonnull mutableContext, SDWebImageOptions * _Nonnull mutableOptions, SDImageCoderOptions * _Nonnull decodeOptions);
-
-/**
- This is the image cache protocol to provide custom image cache for `SDWebImageManager`.
- Though the best practice to custom image cache, is to write your own class which conform `SDMemoryCache` or `SDDiskCache` protocol for `SDImageCache` class (See more on `SDImageCacheConfig.memoryCacheClass & SDImageCacheConfig.diskCacheClass`).
- However, if your own cache implementation contains more advanced feature beyond `SDImageCache` itself, you can consider to provide this instead. For example, you can even use a cache manager like `SDImageCachesManager` to register multiple caches.
- */
-@protocol SDImageCache <NSObject>
-
-@required
-/**
- Query the cached image from image cache for given key. The operation can be used to cancel the query.
- If image is cached in memory, completion is called synchronously, else asynchronously and depends on the options arg (See `SDWebImageQueryDiskSync`)
-
- @param key The image cache key
- @param options A mask to specify options to use for this query
- @param context A context contains different options to perform specify changes or processes, see `SDWebImageContextOption`. This hold the extra objects which `options` enum can not hold.
- @param completionBlock The completion block. Will not get called if the operation is cancelled
- @return The operation for this query
- */
-- (nullable id<SDWebImageOperation>)queryImageForKey:(nullable NSString *)key
-                                             options:(SDWebImageOptions)options
-                                             context:(nullable SDWebImageContext *)context
-                                          completion:(nullable SDImageCacheQueryCompletionBlock)completionBlock;
-
-/**
- Query the cached image from image cache for given key. The operation can be used to cancel the query.
- If image is cached in memory, completion is called synchronously, else asynchronously and depends on the options arg (See `SDWebImageQueryDiskSync`)
-
- @param key The image cache key
- @param options A mask to specify options to use for this query
- @param context A context contains different options to perform specify changes or processes, see `SDWebImageContextOption`. This hold the extra objects which `options` enum can not hold.
- @param cacheType Specify where to query the cache from. By default we use `.all`, which means both memory cache and disk cache. You can choose to query memory only or disk only as well. Pass `.none` is invalid and callback with nil immediately.
- @param completionBlock The completion block. Will not get called if the operation is cancelled
- @return The operation for this query
- */
-- (nullable id<SDWebImageOperation>)queryImageForKey:(nullable NSString *)key
-                                             options:(SDWebImageOptions)options
-                                             context:(nullable SDWebImageContext *)context
-                                           cacheType:(SDImageCacheType)cacheType
-                                          completion:(nullable SDImageCacheQueryCompletionBlock)completionBlock;
-
-/**
- Store the image into image cache for the given key. If cache type is memory only, completion is called synchronously, else asynchronously.
-
- @param image The image to store
- @param imageData The image data to be used for disk storage
- @param key The image cache key
- @param cacheType The image store op cache type
- @param completionBlock A block executed after the operation is finished
- */
-- (void)storeImage:(nullable UIImage *)image
-         imageData:(nullable NSData *)imageData
-            forKey:(nullable NSString *)key
-         cacheType:(SDImageCacheType)cacheType
-        completion:(nullable SDWebImageNoParamsBlock)completionBlock;
-
-/**
- Remove the image from image cache for the given key. If cache type is memory only, completion is called synchronously, else asynchronously.
-
- @param key The image cache key
- @param cacheType The image remove op cache type
- @param completionBlock A block executed after the operation is finished
- */
-- (void)removeImageForKey:(nullable NSString *)key
-                cacheType:(SDImageCacheType)cacheType
-               completion:(nullable SDWebImageNoParamsBlock)completionBlock;
-
-/**
- Check if image cache contains the image for the given key (does not load the image). If image is cached in memory, completion is called synchronously, else asynchronously.
-
- @param key The image cache key
- @param cacheType The image contains op cache type
- @param completionBlock A block executed after the operation is finished.
- */
-- (void)containsImageForKey:(nullable NSString *)key
-                  cacheType:(SDImageCacheType)cacheType
-                 completion:(nullable SDImageCacheContainsCompletionBlock)completionBlock;
-
-/**
- Clear all the cached images for image cache. If cache type is memory only, completion is called synchronously, else asynchronously.
-
- @param cacheType The image clear op cache type
- @param completionBlock A block executed after the operation is finished
- */
-- (void)clearWithCacheType:(SDImageCacheType)cacheType
-                completion:(nullable SDWebImageNoParamsBlock)completionBlock;
-
-@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDImageCacheDefine.m

@@ -1,138 +0,0 @@
-/*
- * This file is part of the SDWebImage package.
- * (c) Olivier Poitrey <rs@dailymotion.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-#import "SDImageCacheDefine.h"
-#import "SDImageCodersManager.h"
-#import "SDImageCoderHelper.h"
-#import "SDAnimatedImage.h"
-#import "UIImage+Metadata.h"
-#import "SDInternalMacros.h"
-
-#import <CoreServices/CoreServices.h>
-
-SDImageCoderOptions * _Nonnull SDGetDecodeOptionsFromContext(SDWebImageContext * _Nullable context, SDWebImageOptions options, NSString * _Nonnull cacheKey) {
-    BOOL decodeFirstFrame = SD_OPTIONS_CONTAINS(options, SDWebImageDecodeFirstFrameOnly);
-    NSNumber *scaleValue = context[SDWebImageContextImageScaleFactor];
-    CGFloat scale = scaleValue.doubleValue >= 1 ? scaleValue.doubleValue : SDImageScaleFactorForKey(cacheKey);
-    NSNumber *preserveAspectRatioValue = context[SDWebImageContextImagePreserveAspectRatio];
-    NSValue *thumbnailSizeValue;
-    BOOL shouldScaleDown = SD_OPTIONS_CONTAINS(options, SDWebImageScaleDownLargeImages);
-    if (shouldScaleDown) {
-        CGFloat thumbnailPixels = SDImageCoderHelper.defaultScaleDownLimitBytes / 4;
-        CGFloat dimension = ceil(sqrt(thumbnailPixels));
-        thumbnailSizeValue = @(CGSizeMake(dimension, dimension));
-    }
-    if (context[SDWebImageContextImageThumbnailPixelSize]) {
-        thumbnailSizeValue = context[SDWebImageContextImageThumbnailPixelSize];
-    }
-    NSString *typeIdentifierHint = context[SDWebImageContextImageTypeIdentifierHint];
-    NSString *fileExtensionHint;
-    if (!typeIdentifierHint) {
-        // UTI has high priority
-        fileExtensionHint = cacheKey.pathExtension; // without dot
-        if (fileExtensionHint.length == 0) {
-            // Ignore file extension which is empty
-            fileExtensionHint = nil;
-        }
-    }
-    
-    // First check if user provided decode options
-    SDImageCoderMutableOptions *mutableCoderOptions;
-    if (context[SDWebImageContextImageDecodeOptions] != nil) {
-        mutableCoderOptions = [NSMutableDictionary dictionaryWithDictionary:context[SDWebImageContextImageDecodeOptions]];
-    } else {
-        mutableCoderOptions = [NSMutableDictionary dictionaryWithCapacity:6];
-    }
-    
-    // Override individual options
-    mutableCoderOptions[SDImageCoderDecodeFirstFrameOnly] = @(decodeFirstFrame);
-    mutableCoderOptions[SDImageCoderDecodeScaleFactor] = @(scale);
-    mutableCoderOptions[SDImageCoderDecodePreserveAspectRatio] = preserveAspectRatioValue;
-    mutableCoderOptions[SDImageCoderDecodeThumbnailPixelSize] = thumbnailSizeValue;
-    mutableCoderOptions[SDImageCoderDecodeTypeIdentifierHint] = typeIdentifierHint;
-    mutableCoderOptions[SDImageCoderDecodeFileExtensionHint] = fileExtensionHint;
-    
-    return [mutableCoderOptions copy];
-}
-
-void SDSetDecodeOptionsToContext(SDWebImageMutableContext * _Nonnull mutableContext, SDWebImageOptions * _Nonnull mutableOptions, SDImageCoderOptions * _Nonnull decodeOptions) {
-    if ([decodeOptions[SDImageCoderDecodeFirstFrameOnly] boolValue]) {
-        *mutableOptions |= SDWebImageDecodeFirstFrameOnly;
-    } else {
-        *mutableOptions &= ~SDWebImageDecodeFirstFrameOnly;
-    }
-    
-    mutableContext[SDWebImageContextImageScaleFactor] = decodeOptions[SDImageCoderDecodeScaleFactor];
-    mutableContext[SDWebImageContextImagePreserveAspectRatio] = decodeOptions[SDImageCoderDecodePreserveAspectRatio];
-    mutableContext[SDWebImageContextImageThumbnailPixelSize] = decodeOptions[SDImageCoderDecodeThumbnailPixelSize];
-    
-    NSString *typeIdentifierHint = decodeOptions[SDImageCoderDecodeTypeIdentifierHint];
-    if (!typeIdentifierHint) {
-        NSString *fileExtensionHint = decodeOptions[SDImageCoderDecodeFileExtensionHint];
-        if (fileExtensionHint) {
-            typeIdentifierHint = (__bridge_transfer NSString *)UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, (__bridge CFStringRef)fileExtensionHint, kUTTypeImage);
-            // Ignore dynamic UTI
-            if (UTTypeIsDynamic((__bridge CFStringRef)typeIdentifierHint)) {
-                typeIdentifierHint = nil;
-            }
-        }
-    }
-    mutableContext[SDWebImageContextImageTypeIdentifierHint] = typeIdentifierHint;
-}
-
-UIImage * _Nullable SDImageCacheDecodeImageData(NSData * _Nonnull imageData, NSString * _Nonnull cacheKey, SDWebImageOptions options, SDWebImageContext * _Nullable context) {
-    NSCParameterAssert(imageData);
-    NSCParameterAssert(cacheKey);
-    UIImage *image;
-    SDImageCoderOptions *coderOptions = SDGetDecodeOptionsFromContext(context, options, cacheKey);
-    BOOL decodeFirstFrame = SD_OPTIONS_CONTAINS(options, SDWebImageDecodeFirstFrameOnly);
-    CGFloat scale = [coderOptions[SDImageCoderDecodeScaleFactor] doubleValue];
-    
-    // Grab the image coder
-    id<SDImageCoder> imageCoder = context[SDWebImageContextImageCoder];
-    if (!imageCoder) {
-        imageCoder = [SDImageCodersManager sharedManager];
-    }
-    
-    if (!decodeFirstFrame) {
-        Class animatedImageClass = context[SDWebImageContextAnimatedImageClass];
-        // check whether we should use `SDAnimatedImage`
-        if ([animatedImageClass isSubclassOfClass:[UIImage class]] && [animatedImageClass conformsToProtocol:@protocol(SDAnimatedImage)]) {
-            image = [[animatedImageClass alloc] initWithData:imageData scale:scale options:coderOptions];
-            if (image) {
-                // Preload frames if supported
-                if (options & SDWebImagePreloadAllFrames && [image respondsToSelector:@selector(preloadAllFrames)]) {
-                    [((id<SDAnimatedImage>)image) preloadAllFrames];
-                }
-            } else {
-                // Check image class matching
-                if (options & SDWebImageMatchAnimatedImageClass) {
-                    return nil;
-                }
-            }
-        }
-    }
-    if (!image) {
-        image = [imageCoder decodedImageWithData:imageData options:coderOptions];
-    }
-    if (image) {
-        BOOL shouldDecode = !SD_OPTIONS_CONTAINS(options, SDWebImageAvoidDecodeImage);
-        BOOL lazyDecode = [coderOptions[SDImageCoderDecodeUseLazyDecoding] boolValue];
-        if (lazyDecode) {
-            // lazyDecode = NO means we should not forceDecode, highest priority
-            shouldDecode = NO;
-        }
-        if (shouldDecode) {
-            image = [SDImageCoderHelper decodedImageWithImage:image];
-        }
-        // assign the decode options, to let manager check whether to re-decode if needed
-        image.sd_decodeOptions = coderOptions;
-    }
-    
-    return image;
-}

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDImageCachesManager.h

@@ -1,81 +0,0 @@
-/*
- * This file is part of the SDWebImage package.
- * (c) Olivier Poitrey <rs@dailymotion.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-#import <Foundation/Foundation.h>
-#import "SDImageCacheDefine.h"
-
-/// Policy for cache operation
-typedef NS_ENUM(NSUInteger, SDImageCachesManagerOperationPolicy) {
-    SDImageCachesManagerOperationPolicySerial, // process all caches serially (from the highest priority to the lowest priority cache by order)
-    SDImageCachesManagerOperationPolicyConcurrent, // process all caches concurrently
-    SDImageCachesManagerOperationPolicyHighestOnly, // process the highest priority cache only
-    SDImageCachesManagerOperationPolicyLowestOnly // process the lowest priority cache only
-};
-
-/**
- A caches manager to manage multiple caches.
- */
-@interface SDImageCachesManager : NSObject <SDImageCache>
-
-/**
- Returns the global shared caches manager instance. By default we will set [`SDImageCache.sharedImageCache`] into the caches array.
- */
-@property (nonatomic, class, readonly, nonnull) SDImageCachesManager *sharedManager;
-
-// These are op policy for cache manager.
-
-/**
- Operation policy for query op.
- Defaults to `Serial`, means query all caches serially (one completion called then next begin) until one cache query success (`image` != nil).
- */
-@property (nonatomic, assign) SDImageCachesManagerOperationPolicy queryOperationPolicy;
-
-/**
- Operation policy for store op.
- Defaults to `HighestOnly`, means store to the highest priority cache only.
- */
-@property (nonatomic, assign) SDImageCachesManagerOperationPolicy storeOperationPolicy;
-
-/**
- Operation policy for remove op.
- Defaults to `Concurrent`, means remove all caches concurrently.
- */
-@property (nonatomic, assign) SDImageCachesManagerOperationPolicy removeOperationPolicy;
-
-/**
- Operation policy for contains op.
- Defaults to `Serial`, means check all caches serially (one completion called then next begin) until one cache check success (`containsCacheType` != None).
- */
-@property (nonatomic, assign) SDImageCachesManagerOperationPolicy containsOperationPolicy;
-
-/**
- Operation policy for clear op.
- Defaults to `Concurrent`, means clear all caches concurrently.
- */
-@property (nonatomic, assign) SDImageCachesManagerOperationPolicy clearOperationPolicy;
-
-/**
- All caches in caches manager. The caches array is a priority queue, which means the later added cache will have the highest priority
- */
-@property (nonatomic, copy, nullable) NSArray<id<SDImageCache>> *caches;
-
-/**
- Add a new cache to the end of caches array. Which has the highest priority.
- 
- @param cache cache
- */
-- (void)addCache:(nonnull id<SDImageCache>)cache;
-
-/**
- Remove a cache in the caches array.
- 
- @param cache cache
- */
-- (void)removeCache:(nonnull id<SDImageCache>)cache;
-
-@end