@momo-kits/native-kits 0.0.1-beta.3 → 0.0.1-beta.5

package/example/ios/Pods/SDWebImage/SDWebImage/Core/UIView+WebCache.m

@@ -0,0 +1,446 @@
+/*
+ * 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 "UIView+WebCache.h"
+#import "objc/runtime.h"
+#import "UIView+WebCacheOperation.h"
+#import "SDWebImageError.h"
+#import "SDInternalMacros.h"
+#import "SDWebImageTransitionInternal.h"
+#import "SDImageCache.h"
+
+const int64_t SDWebImageProgressUnitCountUnknown = 1LL;
+
+@implementation UIView (WebCache)
+
+- (nullable NSURL *)sd_imageURL {
+    return objc_getAssociatedObject(self, @selector(sd_imageURL));
+}
+
+- (void)setSd_imageURL:(NSURL * _Nullable)sd_imageURL {
+    objc_setAssociatedObject(self, @selector(sd_imageURL), sd_imageURL, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (nullable NSString *)sd_latestOperationKey {
+    return objc_getAssociatedObject(self, @selector(sd_latestOperationKey));
+}
+
+- (void)setSd_latestOperationKey:(NSString * _Nullable)sd_latestOperationKey {
+    objc_setAssociatedObject(self, @selector(sd_latestOperationKey), sd_latestOperationKey, OBJC_ASSOCIATION_COPY_NONATOMIC);
+}
+
+- (NSProgress *)sd_imageProgress {
+    NSProgress *progress = objc_getAssociatedObject(self, @selector(sd_imageProgress));
+    if (!progress) {
+        progress = [[NSProgress alloc] initWithParent:nil userInfo:nil];
+        self.sd_imageProgress = progress;
+    }
+    return progress;
+}
+
+- (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
+    objc_setAssociatedObject(self, @selector(sd_imageProgress), sd_imageProgress, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (nullable id<SDWebImageOperation>)sd_internalSetImageWithURL:(nullable NSURL *)url
+                                              placeholderImage:(nullable UIImage *)placeholder
+                                                       options:(SDWebImageOptions)options
+                                                       context:(nullable SDWebImageContext *)context
+                                                 setImageBlock:(nullable SDSetImageBlock)setImageBlock
+                                                      progress:(nullable SDImageLoaderProgressBlock)progressBlock
+                                                     completed:(nullable SDInternalCompletionBlock)completedBlock {
+    if (context) {
+        // copy to avoid mutable object
+        context = [context copy];
+    } else {
+        context = [NSDictionary dictionary];
+    }
+    NSString *validOperationKey = context[SDWebImageContextSetImageOperationKey];
+    if (!validOperationKey) {
+        // pass through the operation key to downstream, which can used for tracing operation or image view class
+        validOperationKey = NSStringFromClass([self class]);
+        SDWebImageMutableContext *mutableContext = [context mutableCopy];
+        mutableContext[SDWebImageContextSetImageOperationKey] = validOperationKey;
+        context = [mutableContext copy];
+    }
+    self.sd_latestOperationKey = validOperationKey;
+    [self sd_cancelImageLoadOperationWithKey:validOperationKey];
+    self.sd_imageURL = url;
+    
+    SDWebImageManager *manager = context[SDWebImageContextCustomManager];
+    if (!manager) {
+        manager = [SDWebImageManager sharedManager];
+    } else {
+        // remove this manager to avoid retain cycle (manger -> loader -> operation -> context -> manager)
+        SDWebImageMutableContext *mutableContext = [context mutableCopy];
+        mutableContext[SDWebImageContextCustomManager] = nil;
+        context = [mutableContext copy];
+    }
+    
+    BOOL shouldUseWeakCache = NO;
+    if ([manager.imageCache isKindOfClass:SDImageCache.class]) {
+        shouldUseWeakCache = ((SDImageCache *)manager.imageCache).config.shouldUseWeakMemoryCache;
+    }
+    if (!(options & SDWebImageDelayPlaceholder)) {
+        if (shouldUseWeakCache) {
+            NSString *key = [manager cacheKeyForURL:url context:context];
+            // call memory cache to trigger weak cache sync logic, ignore the return value and go on normal query
+            // this unfortunately will cause twice memory cache query, but it's fast enough
+            // in the future the weak cache feature may be re-design or removed
+            [((SDImageCache *)manager.imageCache) imageFromMemoryCacheForKey:key];
+        }
+        dispatch_main_async_safe(^{
+            [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:SDImageCacheTypeNone imageURL:url];
+        });
+    }
+    
+    id <SDWebImageOperation> operation = nil;
+    
+    if (url) {
+        // reset the progress
+        NSProgress *imageProgress = objc_getAssociatedObject(self, @selector(sd_imageProgress));
+        if (imageProgress) {
+            imageProgress.totalUnitCount = 0;
+            imageProgress.completedUnitCount = 0;
+        }
+        
+#if SD_UIKIT || SD_MAC
+        // check and start image indicator
+        [self sd_startImageIndicator];
+        id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
+#endif
+        
+        SDImageLoaderProgressBlock combinedProgressBlock = ^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
+            if (imageProgress) {
+                imageProgress.totalUnitCount = expectedSize;
+                imageProgress.completedUnitCount = receivedSize;
+            }
+#if SD_UIKIT || SD_MAC
+            if ([imageIndicator respondsToSelector:@selector(updateIndicatorProgress:)]) {
+                double progress = 0;
+                if (expectedSize != 0) {
+                    progress = (double)receivedSize / expectedSize;
+                }
+                progress = MAX(MIN(progress, 1), 0); // 0.0 - 1.0
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    [imageIndicator updateIndicatorProgress:progress];
+                });
+            }
+#endif
+            if (progressBlock) {
+                progressBlock(receivedSize, expectedSize, targetURL);
+            }
+        };
+        @weakify(self);
+        operation = [manager loadImageWithURL:url options:options context:context progress:combinedProgressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
+            @strongify(self);
+            if (!self) { return; }
+            // if the progress not been updated, mark it to complete state
+            if (imageProgress && finished && !error && imageProgress.totalUnitCount == 0 && imageProgress.completedUnitCount == 0) {
+                imageProgress.totalUnitCount = SDWebImageProgressUnitCountUnknown;
+                imageProgress.completedUnitCount = SDWebImageProgressUnitCountUnknown;
+            }
+            
+#if SD_UIKIT || SD_MAC
+            // check and stop image indicator
+            if (finished) {
+                [self sd_stopImageIndicator];
+            }
+#endif
+            
+            BOOL shouldCallCompletedBlock = finished || (options & SDWebImageAvoidAutoSetImage);
+            BOOL shouldNotSetImage = ((image && (options & SDWebImageAvoidAutoSetImage)) ||
+                                      (!image && !(options & SDWebImageDelayPlaceholder)));
+            SDWebImageNoParamsBlock callCompletedBlockClosure = ^{
+                if (!self) { return; }
+                if (!shouldNotSetImage) {
+                    [self sd_setNeedsLayout];
+                }
+                if (completedBlock && shouldCallCompletedBlock) {
+                    completedBlock(image, data, error, cacheType, finished, url);
+                }
+            };
+            
+            // case 1a: we got an image, but the SDWebImageAvoidAutoSetImage flag is set
+            // OR
+            // case 1b: we got no image and the SDWebImageDelayPlaceholder is not set
+            if (shouldNotSetImage) {
+                dispatch_main_async_safe(callCompletedBlockClosure);
+                return;
+            }
+            
+            UIImage *targetImage = nil;
+            NSData *targetData = nil;
+            if (image) {
+                // case 2a: we got an image and the SDWebImageAvoidAutoSetImage is not set
+                targetImage = image;
+                targetData = data;
+            } else if (options & SDWebImageDelayPlaceholder) {
+                // case 2b: we got no image and the SDWebImageDelayPlaceholder flag is set
+                targetImage = placeholder;
+                targetData = nil;
+            }
+            
+#if SD_UIKIT || SD_MAC
+            // check whether we should use the image transition
+            SDWebImageTransition *transition = nil;
+            BOOL shouldUseTransition = NO;
+            if (options & SDWebImageForceTransition) {
+                // Always
+                shouldUseTransition = YES;
+            } else if (cacheType == SDImageCacheTypeNone) {
+                // From network
+                shouldUseTransition = YES;
+            } else {
+                // From disk (and, user don't use sync query)
+                if (cacheType == SDImageCacheTypeMemory) {
+                    shouldUseTransition = NO;
+                } else if (cacheType == SDImageCacheTypeDisk) {
+                    if (options & SDWebImageQueryMemoryDataSync || options & SDWebImageQueryDiskDataSync) {
+                        shouldUseTransition = NO;
+                    } else {
+                        shouldUseTransition = YES;
+                    }
+                } else {
+                    // Not valid cache type, fallback
+                    shouldUseTransition = NO;
+                }
+            }
+            if (finished && shouldUseTransition) {
+                transition = self.sd_imageTransition;
+            }
+#endif
+            dispatch_main_async_safe(^{
+#if SD_UIKIT || SD_MAC
+                [self sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:transition cacheType:cacheType imageURL:imageURL];
+#else
+                [self sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:cacheType imageURL:imageURL];
+#endif
+                callCompletedBlockClosure();
+            });
+        }];
+        [self sd_setImageLoadOperation:operation forKey:validOperationKey];
+    } else {
+#if SD_UIKIT || SD_MAC
+        [self sd_stopImageIndicator];
+#endif
+        if (completedBlock) {
+            dispatch_main_async_safe(^{
+                NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey : @"Image url is nil"}];
+                completedBlock(nil, nil, error, SDImageCacheTypeNone, YES, url);
+            });
+        }
+    }
+    
+    return operation;
+}
+
+- (void)sd_cancelCurrentImageLoad {
+    [self sd_cancelImageLoadOperationWithKey:self.sd_latestOperationKey];
+    self.sd_latestOperationKey = nil;
+}
+
+- (void)sd_setImage:(UIImage *)image imageData:(NSData *)imageData basedOnClassOrViaCustomSetImageBlock:(SDSetImageBlock)setImageBlock cacheType:(SDImageCacheType)cacheType imageURL:(NSURL *)imageURL {
+#if SD_UIKIT || SD_MAC
+    [self sd_setImage:image imageData:imageData basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:nil cacheType:cacheType imageURL:imageURL];
+#else
+    // watchOS does not support view transition. Simplify the logic
+    if (setImageBlock) {
+        setImageBlock(image, imageData, cacheType, imageURL);
+    } else if ([self isKindOfClass:[UIImageView class]]) {
+        UIImageView *imageView = (UIImageView *)self;
+        [imageView setImage:image];
+    }
+#endif
+}
+
+#if SD_UIKIT || SD_MAC
+- (void)sd_setImage:(UIImage *)image imageData:(NSData *)imageData basedOnClassOrViaCustomSetImageBlock:(SDSetImageBlock)setImageBlock transition:(SDWebImageTransition *)transition cacheType:(SDImageCacheType)cacheType imageURL:(NSURL *)imageURL {
+    UIView *view = self;
+    SDSetImageBlock finalSetImageBlock;
+    if (setImageBlock) {
+        finalSetImageBlock = setImageBlock;
+    } else if ([view isKindOfClass:[UIImageView class]]) {
+        UIImageView *imageView = (UIImageView *)view;
+        finalSetImageBlock = ^(UIImage *setImage, NSData *setImageData, SDImageCacheType setCacheType, NSURL *setImageURL) {
+            imageView.image = setImage;
+        };
+    }
+#if SD_UIKIT
+    else if ([view isKindOfClass:[UIButton class]]) {
+        UIButton *button = (UIButton *)view;
+        finalSetImageBlock = ^(UIImage *setImage, NSData *setImageData, SDImageCacheType setCacheType, NSURL *setImageURL) {
+            [button setImage:setImage forState:UIControlStateNormal];
+        };
+    }
+#endif
+#if SD_MAC
+    else if ([view isKindOfClass:[NSButton class]]) {
+        NSButton *button = (NSButton *)view;
+        finalSetImageBlock = ^(UIImage *setImage, NSData *setImageData, SDImageCacheType setCacheType, NSURL *setImageURL) {
+            button.image = setImage;
+        };
+    }
+#endif
+    
+    if (transition) {
+        NSString *originalOperationKey = view.sd_latestOperationKey;
+
+#if SD_UIKIT
+        [UIView transitionWithView:view duration:0 options:0 animations:^{
+            if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                return;
+            }
+            // 0 duration to let UIKit render placeholder and prepares block
+            if (transition.prepares) {
+                transition.prepares(view, image, imageData, cacheType, imageURL);
+            }
+        } completion:^(BOOL tempFinished) {
+            [UIView transitionWithView:view duration:transition.duration options:transition.animationOptions animations:^{
+                if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                    return;
+                }
+                if (finalSetImageBlock && !transition.avoidAutoSetImage) {
+                    finalSetImageBlock(image, imageData, cacheType, imageURL);
+                }
+                if (transition.animations) {
+                    transition.animations(view, image);
+                }
+            } completion:^(BOOL finished) {
+                if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                    return;
+                }
+                if (transition.completion) {
+                    transition.completion(finished);
+                }
+            }];
+        }];
+#elif SD_MAC
+        [NSAnimationContext runAnimationGroup:^(NSAnimationContext * _Nonnull prepareContext) {
+            if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                return;
+            }
+            // 0 duration to let AppKit render placeholder and prepares block
+            prepareContext.duration = 0;
+            if (transition.prepares) {
+                transition.prepares(view, image, imageData, cacheType, imageURL);
+            }
+        } completionHandler:^{
+            [NSAnimationContext runAnimationGroup:^(NSAnimationContext * _Nonnull context) {
+                if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                    return;
+                }
+                context.duration = transition.duration;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+                CAMediaTimingFunction *timingFunction = transition.timingFunction;
+#pragma clang diagnostic pop
+                if (!timingFunction) {
+                    timingFunction = SDTimingFunctionFromAnimationOptions(transition.animationOptions);
+                }
+                context.timingFunction = timingFunction;
+                context.allowsImplicitAnimation = SD_OPTIONS_CONTAINS(transition.animationOptions, SDWebImageAnimationOptionAllowsImplicitAnimation);
+                if (finalSetImageBlock && !transition.avoidAutoSetImage) {
+                    finalSetImageBlock(image, imageData, cacheType, imageURL);
+                }
+                CATransition *trans = SDTransitionFromAnimationOptions(transition.animationOptions);
+                if (trans) {
+                    [view.layer addAnimation:trans forKey:kCATransition];
+                }
+                if (transition.animations) {
+                    transition.animations(view, image);
+                }
+            } completionHandler:^{
+                if (!view.sd_latestOperationKey || ![originalOperationKey isEqualToString:view.sd_latestOperationKey]) {
+                    return;
+                }
+                if (transition.completion) {
+                    transition.completion(YES);
+                }
+            }];
+        }];
+#endif
+    } else {
+        if (finalSetImageBlock) {
+            finalSetImageBlock(image, imageData, cacheType, imageURL);
+        }
+    }
+}
+#endif
+
+- (void)sd_setNeedsLayout {
+#if SD_UIKIT
+    [self setNeedsLayout];
+#elif SD_MAC
+    [self setNeedsLayout:YES];
+#elif SD_WATCH
+    // Do nothing because WatchKit automatically layout the view after property change
+#endif
+}
+
+#if SD_UIKIT || SD_MAC
+
+#pragma mark - Image Transition
+- (SDWebImageTransition *)sd_imageTransition {
+    return objc_getAssociatedObject(self, @selector(sd_imageTransition));
+}
+
+- (void)setSd_imageTransition:(SDWebImageTransition *)sd_imageTransition {
+    objc_setAssociatedObject(self, @selector(sd_imageTransition), sd_imageTransition, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+#pragma mark - Indicator
+- (id<SDWebImageIndicator>)sd_imageIndicator {
+    return objc_getAssociatedObject(self, @selector(sd_imageIndicator));
+}
+
+- (void)setSd_imageIndicator:(id<SDWebImageIndicator>)sd_imageIndicator {
+    // Remove the old indicator view
+    id<SDWebImageIndicator> previousIndicator = self.sd_imageIndicator;
+    [previousIndicator.indicatorView removeFromSuperview];
+    
+    objc_setAssociatedObject(self, @selector(sd_imageIndicator), sd_imageIndicator, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    
+    // Add the new indicator view
+    UIView *view = sd_imageIndicator.indicatorView;
+    if (CGRectEqualToRect(view.frame, CGRectZero)) {
+        view.frame = self.bounds;
+    }
+    // Center the indicator view
+#if SD_MAC
+    [view setFrameOrigin:CGPointMake(round((NSWidth(self.bounds) - NSWidth(view.frame)) / 2), round((NSHeight(self.bounds) - NSHeight(view.frame)) / 2))];
+#else
+    view.center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
+#endif
+    view.hidden = NO;
+    [self addSubview:view];
+}
+
+- (void)sd_startImageIndicator {
+    id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
+    if (!imageIndicator) {
+        return;
+    }
+    dispatch_main_async_safe(^{
+        [imageIndicator startAnimatingIndicator];
+    });
+}
+
+- (void)sd_stopImageIndicator {
+    id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
+    if (!imageIndicator) {
+        return;
+    }
+    dispatch_main_async_safe(^{
+        [imageIndicator stopAnimatingIndicator];
+    });
+}
+
+#endif
+
+@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/UIView+WebCacheOperation.h

@@ -0,0 +1,48 @@
+/*
+ * 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 "SDWebImageCompat.h"
+#import "SDWebImageOperation.h"
+
+/**
+ These methods are used to support canceling for UIView image loading, it's designed to be used internal but not external.
+ All the stored operations are weak, so it will be dealloced after image loading finished. If you need to store operations, use your own class to keep a strong reference for them.
+ */
+@interface UIView (WebCacheOperation)
+
+/**
+ *  Get the image load operation for key
+ *
+ *  @param key key for identifying the operations
+ *  @return the image load operation
+ */
+- (nullable id<SDWebImageOperation>)sd_imageLoadOperationForKey:(nullable NSString *)key;
+
+/**
+ *  Set the image load operation (storage in a UIView based weak map table)
+ *
+ *  @param operation the operation
+ *  @param key       key for storing the operation
+ */
+- (void)sd_setImageLoadOperation:(nullable id<SDWebImageOperation>)operation forKey:(nullable NSString *)key;
+
+/**
+ *  Cancel the operation for the current UIView and key
+ *
+ *  @param key key for identifying the operations
+ */
+- (void)sd_cancelImageLoadOperationWithKey:(nullable NSString *)key;
+
+/**
+ *  Just remove the operation corresponding to the current UIView and key without cancelling them
+ *
+ *  @param key key for identifying the operations
+ */
+- (void)sd_removeImageLoadOperationWithKey:(nullable NSString *)key;
+
+@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/UIView+WebCacheOperation.m

@@ -0,0 +1,82 @@
+/*
+ * 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 "UIView+WebCacheOperation.h"
+#import "objc/runtime.h"
+
+// key is strong, value is weak because operation instance is retained by SDWebImageManager's runningOperations property
+// we should use lock to keep thread-safe because these method may not be accessed from main queue
+typedef NSMapTable<NSString *, id<SDWebImageOperation>> SDOperationsDictionary;
+
+@implementation UIView (WebCacheOperation)
+
+- (SDOperationsDictionary *)sd_operationDictionary {
+    @synchronized(self) {
+        SDOperationsDictionary *operations = objc_getAssociatedObject(self, @selector(sd_operationDictionary));
+        if (operations) {
+            return operations;
+        }
+        operations = [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsStrongMemory valueOptions:NSPointerFunctionsWeakMemory capacity:0];
+        objc_setAssociatedObject(self, @selector(sd_operationDictionary), operations, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+        return operations;
+    }
+}
+
+- (nullable id<SDWebImageOperation>)sd_imageLoadOperationForKey:(nullable NSString *)key  {
+    id<SDWebImageOperation> operation;
+    if (key) {
+        SDOperationsDictionary *operationDictionary = [self sd_operationDictionary];
+        @synchronized (self) {
+            operation = [operationDictionary objectForKey:key];
+        }
+    }
+    return operation;
+}
+
+- (void)sd_setImageLoadOperation:(nullable id<SDWebImageOperation>)operation forKey:(nullable NSString *)key {
+    if (key) {
+        [self sd_cancelImageLoadOperationWithKey:key];
+        if (operation) {
+            SDOperationsDictionary *operationDictionary = [self sd_operationDictionary];
+            @synchronized (self) {
+                [operationDictionary setObject:operation forKey:key];
+            }
+        }
+    }
+}
+
+- (void)sd_cancelImageLoadOperationWithKey:(nullable NSString *)key {
+    if (key) {
+        // Cancel in progress downloader from queue
+        SDOperationsDictionary *operationDictionary = [self sd_operationDictionary];
+        id<SDWebImageOperation> operation;
+        
+        @synchronized (self) {
+            operation = [operationDictionary objectForKey:key];
+        }
+        if (operation) {
+            if ([operation respondsToSelector:@selector(cancel)]) {
+                [operation cancel];
+            }
+            @synchronized (self) {
+                [operationDictionary removeObjectForKey:key];
+            }
+        }
+    }
+}
+
+- (void)sd_removeImageLoadOperationWithKey:(nullable NSString *)key {
+    if (key) {
+        SDOperationsDictionary *operationDictionary = [self sd_operationDictionary];
+        @synchronized (self) {
+            [operationDictionary removeObjectForKey:key];
+        }
+    }
+}
+
+@end

package/example/ios/Pods/SDWebImage/SDWebImage/Private/NSBezierPath+SDRoundedCorners.h

@@ -0,0 +1,24 @@
+/*
+ * 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 "SDWebImageCompat.h"
+
+#if SD_MAC
+
+#import "UIImage+Transform.h"
+
+@interface NSBezierPath (SDRoundedCorners)
+
+/**
+ Convenience way to create a bezier path with the specify rounding corners on macOS. Same as the one on `UIBezierPath`.
+ */
++ (nonnull instancetype)sd_bezierPathWithRoundedRect:(NSRect)rect byRoundingCorners:(SDRectCorner)corners cornerRadius:(CGFloat)cornerRadius;
+
+@end
+
+#endif

package/example/ios/Pods/SDWebImage/SDWebImage/Private/NSBezierPath+SDRoundedCorners.m

@@ -0,0 +1,42 @@
+/*
+ * 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 "NSBezierPath+SDRoundedCorners.h"
+
+#if SD_MAC
+
+@implementation NSBezierPath (SDRoundedCorners)
+
++ (instancetype)sd_bezierPathWithRoundedRect:(NSRect)rect byRoundingCorners:(SDRectCorner)corners cornerRadius:(CGFloat)cornerRadius {
+    NSBezierPath *path = [NSBezierPath bezierPath];
+    
+    CGFloat maxCorner = MIN(NSWidth(rect), NSHeight(rect)) / 2;
+    
+    CGFloat topLeftRadius = MIN(maxCorner, (corners & SDRectCornerTopLeft) ? cornerRadius : 0);
+    CGFloat topRightRadius = MIN(maxCorner, (corners & SDRectCornerTopRight) ? cornerRadius : 0);
+    CGFloat bottomLeftRadius = MIN(maxCorner, (corners & SDRectCornerBottomLeft) ? cornerRadius : 0);
+    CGFloat bottomRightRadius = MIN(maxCorner, (corners & SDRectCornerBottomRight) ? cornerRadius : 0);
+    
+    NSPoint topLeft = NSMakePoint(NSMinX(rect), NSMaxY(rect));
+    NSPoint topRight = NSMakePoint(NSMaxX(rect), NSMaxY(rect));
+    NSPoint bottomLeft = NSMakePoint(NSMinX(rect), NSMinY(rect));
+    NSPoint bottomRight = NSMakePoint(NSMaxX(rect), NSMinY(rect));
+    
+    [path moveToPoint:NSMakePoint(NSMidX(rect), NSMaxY(rect))];
+    [path appendBezierPathWithArcFromPoint:topLeft toPoint:bottomLeft radius:topLeftRadius];
+    [path appendBezierPathWithArcFromPoint:bottomLeft toPoint:bottomRight radius:bottomLeftRadius];
+    [path appendBezierPathWithArcFromPoint:bottomRight toPoint:topRight radius:bottomRightRadius];
+    [path appendBezierPathWithArcFromPoint:topRight toPoint:topLeft radius:topRightRadius];
+    [path closePath];
+    
+    return path;
+}
+
+@end
+
+#endif

package/example/ios/Pods/SDWebImage/SDWebImage/Private/SDAssociatedObject.h

@@ -0,0 +1,14 @@
+/*
+* 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 "SDWebImageCompat.h"
+
+/// Copy the associated object from source image to target image. The associated object including all the category read/write properties.
+/// @param source source
+/// @param target target
+FOUNDATION_EXPORT void SDImageCopyAssociatedObject(UIImage * _Nullable source, UIImage * _Nullable target);

package/example/ios/Pods/SDWebImage/SDWebImage/Private/SDAssociatedObject.m

@@ -0,0 +1,29 @@
+/*
+* 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 "SDAssociatedObject.h"
+#import "UIImage+Metadata.h"
+#import "UIImage+ExtendedCacheData.h"
+#import "UIImage+MemoryCacheCost.h"
+#import "UIImage+ForceDecode.h"
+
+void SDImageCopyAssociatedObject(UIImage * _Nullable source, UIImage * _Nullable target) {
+    if (!source || !target) {
+        return;
+    }
+    // Image Metadata
+    target.sd_isIncremental = source.sd_isIncremental;
+    target.sd_isTransformed = source.sd_isTransformed;
+    target.sd_decodeOptions = source.sd_decodeOptions;
+    target.sd_imageLoopCount = source.sd_imageLoopCount;
+    target.sd_imageFormat = source.sd_imageFormat;
+    // Force Decode
+    target.sd_isDecoded = source.sd_isDecoded;
+    // Extended Cache Data
+    target.sd_extendedObject = source.sd_extendedObject;
+}