:key: Shared Web Credentials
-
-> Shared web credentials is a programming interface that enables native iOS apps to share credentials with their website counterparts. For example, a user may log in to a website in Safari, entering a user name and password, and save those credentials using the iCloud Keychain. Later, the user may run a native app from the same developer, and instead of the app requiring the user to reenter a user name and password, shared web credentials gives it access to the credentials that were entered earlier in Safari. The user can also create new accounts, update passwords, or delete her account from within the app. These changes are then saved and used by Safari.
-
-
-
-```swift
-let keychain = Keychain(server: "https://www.kishikawakatsumi.com", protocolType: .HTTPS)
-
-let username = "kishikawakatsumi@mac.com"
-
-// First, check the credential in the app's Keychain
-if let password = try? keychain.get(username) {
- // If found password in the Keychain,
- // then log into the server
-} else {
- // If not found password in the Keychain,
- // try to read from Shared Web Credentials
- keychain.getSharedPassword(username) { (password, error) -> () in
- if password != nil {
- // If found password in the Shared Web Credentials,
- // then log into the server
- // and save the password to the Keychain
-
- keychain[username] = password
- } else {
- // If not found password either in the Keychain also Shared Web Credentials,
- // prompt for username and password
-
- // Log into server
-
- // If the login is successful,
- // save the credentials to both the Keychain and the Shared Web Credentials.
-
- keychain[username] = inputPassword
- keychain.setSharedPassword(inputPassword, account: username)
- }
- }
-}
-```
-
-#### Request all associated domain's credentials
-
-```swift
-Keychain.requestSharedWebCredential { (credentials, error) -> () in
-
-}
-```
-
-#### Generate strong random password
-
-Generate strong random password that is in the same format used by Safari autofill (xxx-xxx-xxx-xxx).
-
-```swift
-let password = Keychain.generatePassword() // => Nhu-GKm-s3n-pMx
-```
-
-#### How to set up Shared Web Credentials
-
-> 1. Add a com.apple.developer.associated-domains entitlement to your app. This entitlement must include all the domains with which you want to share credentials.
->
-> 2. Add an apple-app-site-association file to your website. This file must include application identifiers for all the apps with which the site wants to share credentials, and it must be properly signed.
->
-> 3. When the app is installed, the system downloads and verifies the site association file for each of its associated domains. If the verification is successful, the app is associated with the domain.
-
-**More details:**
-
-
-### :key: Debugging
-
-#### Display all stored items if print keychain object
-
-```swift
-let keychain = Keychain(server: "https://github.com", protocolType: .https)
-print("\(keychain)")
-```
-
-```
-=>
-[
- [authenticationType: default, key: kishikawakatsumi, server: github.com, class: internetPassword, protocol: https]
- [authenticationType: default, key: hirohamada, server: github.com, class: internetPassword, protocol: https]
- [authenticationType: default, key: honeylemon, server: github.com, class: internetPassword, protocol: https]
-]
-```
-
-#### Obtaining all stored keys
-
-```swift
-let keychain = Keychain(server: "https://github.com", protocolType: .https)
-
-let keys = keychain.allKeys()
-for key in keys {
- print("key: \(key)")
-}
-```
-
-```
-=>
-key: kishikawakatsumi
-key: hirohamada
-key: honeylemon
-```
-
-#### Obtaining all stored items
-
-```swift
-let keychain = Keychain(server: "https://github.com", protocolType: .https)
-
-let items = keychain.allItems()
-for item in items {
- print("item: \(item)")
-}
-```
-
-```
-=>
-item: [authenticationType: Default, key: kishikawakatsumi, server: github.com, class: InternetPassword, protocol: https]
-item: [authenticationType: Default, key: hirohamada, server: github.com, class: InternetPassword, protocol: https]
-item: [authenticationType: Default, key: honeylemon, server: github.com, class: InternetPassword, protocol: https]
-```
-
-## Keychain sharing capability
-
-If you encounter the error below, you need to add an `Keychain.entitlements`.
-
-```
-OSStatus error:[-34018] Internal error when a required entitlement isn't present, client has neither application-identifier nor keychain-access-groups entitlements.
-```
-
-
-
-
-
-## Requirements
-
-| | OS | Swift |
-|------------|------------------------------------------------------------|--------------------|
-| **v1.1.x** | iOS 7+, macOS 10.9+ | 1.1 |
-| **v1.2.x** | iOS 7+, macOS 10.9+ | 1.2 |
-| **v2.0.x** | iOS 7+, macOS 10.9+, watchOS 2+ | 2.0 |
-| **v2.1.x** | iOS 7+, macOS 10.9+, watchOS 2+ | 2.0 |
-| **v2.2.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 2.0, 2.1 |
-| **v2.3.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 2.0, 2.1, 2.2 |
-| **v2.4.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 2.2, 2.3 |
-| **v3.0.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 3.x |
-| **v3.1.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 4.0, 4.1, 4.2 |
-| **v3.2.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 4.0, 4.1, 4.2, 5.0 |
-| **v4.0.x** | iOS 8+, macOS 10.9+, watchOS 2+, tvOS 9+ | 4.0, 4.1, 4.2, 5.1 |
-| **v4.1.x** | iOS 8+, macOS 10.9+, watchOS 3+, tvOS 9+, Mac Catalyst 13+ | 4.0, 4.1, 4.2, 5.1 |
-
-## Installation
-
-### CocoaPods
-
-KeychainAccess is available through [CocoaPods](http://cocoapods.org). To install
-it, simply add the following lines to your Podfile:
-
-```ruby
-use_frameworks!
-pod 'KeychainAccess'
-```
-
-### Carthage
-
-KeychainAccess is available through [Carthage](https://github.com/Carthage/Carthage). To install
-it, simply add the following line to your Cartfile:
-
-`github "kishikawakatsumi/KeychainAccess"`
-
-### Swift Package Manager
-
-KeychainAccess is also available through [Swift Package Manager](https://github.com/apple/swift-package-manager/).
-
-#### Xcode
-
-Select `File > Swift Packages > Add Package Dependency...`,
-
-
-
-#### CLI
-
-First, create `Package.swift` that its package declaration includes:
-
-```swift
-// swift-tools-version:5.0
-import PackageDescription
-
-let package = Package(
- name: "MyLibrary",
- products: [
- .library(name: "MyLibrary", targets: ["MyLibrary"]),
- ],
- dependencies: [
- .package(url: "https://github.com/kishikawakatsumi/KeychainAccess.git", from: "3.0.0"),
- ],
- targets: [
- .target(name: "MyLibrary", dependencies: ["KeychainAccess"]),
- ]
-)
-```
-
-Then, type
-
-```shell
-$ swift build
-```
-
-### To manually add to your project
-
-1. Add `Lib/KeychainAccess.xcodeproj` to your project
-2. Link `KeychainAccess.framework` with your target
-3. Add `Copy Files Build Phase` to include the framework to your application bundle
-
-_See [iOS Example Project](https://github.com/kishikawakatsumi/KeychainAccess/tree/master/Examples/Example-iOS) as reference._
-
-
-
-## Author
-
-kishikawa katsumi, kishikawakatsumi@mac.com
-
-## License
-
-KeychainAccess is available under the MIT license. See the LICENSE file for more info.
diff --git a/Pods/Manifest.lock b/Pods/Manifest.lock
deleted file mode 100644
index 76029f5..0000000
--- a/Pods/Manifest.lock
+++ /dev/null
@@ -1,39 +0,0 @@
-PODS:
- - CocoaLumberjack/Core (3.6.1)
- - CocoaLumberjack/Swift (3.6.1):
- - CocoaLumberjack/Core
- - KeychainAccess (4.1.0)
- - Nuke (8.4.1)
- - ReachabilitySwift (5.0.0)
- - SwiftFormat/CLI (0.40.9)
- - SwiftLint (0.33.0)
-
-DEPENDENCIES:
- - CocoaLumberjack/Swift
- - KeychainAccess (~> 4.1.0)
- - Nuke (~> 8.4.1)
- - ReachabilitySwift
- - SwiftFormat/CLI (~> 0.40.9)
- - SwiftLint
-
-SPEC REPOS:
- https://github.com/CocoaPods/Specs.git:
- - SwiftFormat
- - SwiftLint
- trunk:
- - CocoaLumberjack
- - KeychainAccess
- - Nuke
- - ReachabilitySwift
-
-SPEC CHECKSUMS:
- CocoaLumberjack: b17ae15142558d08bbacf69775fa10c4abbebcc9
- KeychainAccess: 445e28864fe6d3458b41fa211bcdc39890e8bd5a
- Nuke: d780e3507a86b86c589ab3cc5cd302d5456f06fb
- ReachabilitySwift: 985039c6f7b23a1da463388634119492ff86c825
- SwiftFormat: 6b67b6e7fe73d664f0cbb4f13721f130462c86a5
- SwiftLint: fed9c66336e41fc74dc48a73678380718f0c8b0e
-
-PODFILE CHECKSUM: e80b055b782feadf8a435af7d02dd62860179484
-
-COCOAPODS: 1.9.1
diff --git a/Pods/Nuke/LICENSE b/Pods/Nuke/LICENSE
deleted file mode 100644
index e722ad8..0000000
--- a/Pods/Nuke/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015-2020 Alexander Grebenyuk
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/Pods/Nuke/README.md b/Pods/Nuke/README.md
deleted file mode 100644
index 3d2d988..0000000
--- a/Pods/Nuke/README.md
+++ /dev/null
@@ -1,613 +0,0 @@
-
-
-
-
-# Powerful Image Loading System
-
-
-
-
-
-
-
-
-> Upgrading from the previous version? Use a [**Migration Guide**](https://github.com/kean/Nuke/blob/master/Documentation/Migrations).
-
-Nuke provides a simple and efficient way to download and display images in your app. Behind its clear and concise API is an advanced architecture which enables its unique features and offers virtually unlimited possibilities for customization.
-
-> **Fast LRU memory and disk cache** · **Smart background decompression** · **Image processing** · **Resumable downloads** · **Intelligent deduplication** · **Request prioritization** · **Prefetching** · **Rate limiting** · **Progressive JPEG, WebP** · **Animated images** · **Alamofire, WebP, Gifu, FLAnimatedImage integrations** · **Reactive extensions**
-
-
-
-## Getting Started
-
-Nuke is easy to learn and use. Here is an overview of its APIs and features:
-
-- **Image View Extensions** ‣ [UI Extensions](#image-view-extensions) | [Placeholders, Transitions](#placeholders-transitions-content-modes) | [`ImageRequest`](#imagerequest) | [SwiftUI](#swiftui) | [Low Data Mode](#low-data-mode)
-- **Image Processing** ‣ [`Resize`](#resize) | [`GaussianBlur`, Core Image](#gaussianblur-core-image) | [Custom Processors](#custom-processors) | [Smart Decompression](#smart-decompression)
-- **Image Pipeline** ‣ [Load Image](#image-pipeline) | [`ImageTask`](#imagetask) | [Customize Image Pipeline](#customize-image-pipeline) | [Default Pipeline](#default-image-pipeline)
-- **Caching** ‣ [LRU Memory Cache](#lru-memory-cache) | [HTTP Disk Cache](#http-disk-cache) | [Aggressive LRU Disk Cache](#aggressive-lru-disk-cache)
-- **Advanced Features** ‣ [Preheat Images](#image-preheating) | [Progressive Decoding](#progressive-decoding) | [Animated Images](#animated-images) | [WebP](#webp) | [Combine](#combine) | [RxNuke](#rxnuke)
-
-To learn more see a full [**API Reference**](https://kean-org.github.io/docs/nuke/reference/8.0/index.html), and check out the demo project included in the repository. When you are ready to install, follow the [**Installation Guide**](https://github.com/kean/Nuke/blob/master/Documentation/Guides/Installation%20Guide.md). See [**Requirements**](#h_requirements) for a list of supported platforms.
-
-
-
-To learn about the image pipeline itself, see the dedicated section:
-
-- **Image Pipeline** ‣ [Overview](#h_design) | [Data Loading and Caching](#data-loading-and-caching) | [Resumable Downloads](#resumable-downloads) | [Memory Cache](#memory-cache) | [Deduplication](#deduplication) | [Performance](#performance) | [Extensions](#h_plugins)
-
-If you'd like to contribute to Nuke see [**Contributing**](#h_contribute).
-
-
-
-# Image View Extensions
-
-
-
-Download and display an image in an image view with a single line of code:
-
-```swift
-Nuke.loadImage(with: url, into: imageView)
-```
-
-Nuke will check if the image exists in the memory cache, and if it does, will instantly display it. If not, the image data will be loaded, decoded, processed, and decompressed in the background.
-
-> See [Image Pipeline Overview](#h_design) to learn more.
-
-### In a List
-
-When you request a new image for the existing view, Nuke will prepare it for reuse and cancel any outstanding requests for the view. Mangaging images in lists has never been easier.
-
-```swift
-func collectionView(_ collectionView: UICollectionView,
- cellForItemAt indexPath: IndexPath)
- -> UICollectionViewCell {
- Nuke.loadImage(with: url, into: cell.imageView)
-}
-```
-
-> The requests also get canceled automatically when the views are deallocated. Call `Nuke.cancelRequest(for: imageView)` to cancel the request manually.
-
-### Placeholders, Transitions, Content Modes
-
-Use `ImageLoadingOptions` to set a `placeholder`, select one of the built-in `transitions`, or provide a custom one.
-
-```swift
-let options = ImageLoadingOptions(
- placeholder: UIImage(named: "placeholder"),
- transition: .fadeIn(duration: 0.33)
-)
-Nuke.loadImage(with: url, options: options, into: imageView)
-```
-
-You can even customize content modes per image type:
-
-```swift
-let options = ImageLoadingOptions(
- placeholder: UIImage(named: "placeholder"),
- failureImage: UIImage(named: "failureImage"),
- contentModes: .init(success: .scaleAspectFill, failure: .center, placeholder: .center)
-)
-```
-
-> In case you want all image views to have the same behavior, you can modify `ImageLoadingOptions.shared`.
-
-### `ImageRequest`
-
-`ImageRequest` allows you to set image processors, change the request priority and more:
-
-```swift
-let request = ImageRequest(
- url: URL(string: "http://..."),
- processors: [ImageProcessor.Resize(size: imageView.bounds.size)],
- priority: .high
-)
-```
-
-> Another way to apply processors is by setting the default `processors` on `ImagePipeline.Configuration`. These processors will be applied to all images loaded by the pipeline. If the request has a non-empty array of `processors`, they are going to be applied instead.
-
-The advanced options available via `ImageRequestOptions`. For example, you can provide a `filteredURL` to be used as a key for caching in case the URL contains transient query parameters.
-
-```swift
-let request = ImageRequest(
- url: URL(string: "http://example.com/image.jpeg?token=123")!,
- options: ImageRequestOptions(
- filteredURL: "http://example.com/image.jpeg"
- )
-)
-```
-
-> There are more options available, to see all of them check the inline documentation for `ImageRequestOptions`.
-
-### SwiftUI
-
-[`FetchImage`](https://github.com/kean/FetchImage) is a Swift package that makes it easy to download images using Nuke and display them in SwiftUI apps. For more info, see the [introductory post](https://kean.github.io/post/introducing-fetch-image).
-
-> **Note**: This is an API preview, it might change in the future.
-
-```swift
-public struct ImageView: View {
- @ObservedObject var image: FetchImage
-
- public var body: some View {
- ZStack {
- Rectangle().fill(Color.gray)
- image.view?
- .resizable()
- .aspectRatio(contentMode: .fill)
- }
- }
-}
-```
-
-### Low Data Mode
-
-[`FetchImage`](https://github.com/kean/FetchImage) also offers built-in support for low-data mode via a special initializer:
-
-```swift
-FetchImage(regularUrl: highQualityUrl, lowDataUrl: lowQualityUrl)
-```
-
-
-
-# Image Processing
-
-
-
-Nuke features a powerful and efficient image processing infrastructure with multiple built-in processors including `ImageProcessor.Resize`, `.Circle`, `.RoundedCorners`, `.CoreImageFilter`, `.GaussianBlur`.
-
-> This and other screenshots are from the demo project included in the repo.
-
-### `Resize`
-
-To resize an image, use `ImageProcessor.Resize`:
-
-```swift
-ImageRequest(url: url, processors: [
- ImageProcessor.Resize(size: imageView.bounds.size)
-])
-```
-
-By default, the target size is in points. When the image is loaded, Nuke will scale it to fill the target area maintaining the aspect ratio. To crop the image set `crop` to `true`.
-
-> There are a few other options available, see `ImageProcessor.Resize` documentation for more info.
-
-### `GaussianBlur`, Core Image
-
-`ImageProcessor.GaussianBlur` blurs the input image. It is powered by the native `CoreImage` framework. To apply other filters, use `ImageProcessor.CoreImageFilter`:
-
-```swift
-ImageProcessor.CoreImageFilter(name: "CISepiaTone")
-```
-
-> For a complete list of Core Image filters see [Core Image Filter Reference](https://developer.apple.com/library/archive/documentation/GraphicsImaging/Reference/CoreImageFilterReference/index.html).
-
-### Custom Processors
-
-Custom processors need to conform to `ImageProcessing` protocol:
-
-```swift
-public protocol ImageProcessing {
- var identifier: String { get }
- var hashableIdentifier: AnyHashable { get }
-
- func process(image: Image, context: ImageProcessingContext?) -> Image?
-}
-```
-
-The `process` method is self-explanatory. `identifier: String` is used by disk caches, and `hashableIdentifier: AnyHashable` is used by memory caches for which string manipulations would be too slow.
-
-For one-off operations, use `ImageProcessor.Anonymous` to create a processor with a closure.
-
-### Smart Decompression
-
-When you instantiate `UIImage` with `Data`, the data can be in a compressed format like `JPEG`. `UIImage` does _not_ eagerly decompress this data until you display it. This leads to performance issues like scroll view stuttering. To avoid these it, Nuke automatically decompresses the data in the background. Decompression only runs if needed, it won't run for already processed images.
-
-> See [Image and Graphics Best Practices](https://developer.apple.com/videos/play/wwdc2018/219) to learn more about image decoding and downsampling.
-
-
-
-# Image Pipeline
-
-At the core of Nuke is the `ImagePipeline` class. Use the pipeline directly to load images without displaying them:
-
-```swift
-let task = ImagePipeline.shared.loadImage(
- with: url,
- progress: { _, completed, total in
- print("progress updated")
- },
- completion: { result: Result in
- print("task completed")
- }
-)
-```
-
-> To download the data without doing any expensive decoding or processing, use `loadData(with:progress:completion:)`.
-
-### `ImageTask`
-
-When you start the request, the pipeline returns an `ImageTask` object, which can be used for cancelation and more.
-
-```swift
-task.cancel()
-task.priority = .high
-```
-
-### Customize Image Pipeline
-
-If you want to build a system that fits your specific needs, you won't be disappointed. There are a _lot of things_ to tweak. You can set custom data loaders and caches, configure image encoders and decoders, change the number of concurrent operations for each individual stage, disable and enable features like deduplication and rate limiting, and more.
-
-> To learn more see the inline documentation for `ImagePipeline.Configuration` and [Image Pipeline Overview](#h_design).
-
-
-
-Here are the protocols which can be used for customization:
-
-- `DataLoading` – Download (or return cached) image data
-- `DataCaching` – Store image data on disk
-- `ImageDecoding` – Convert data into images
-- `ImageEncoding` - Convert images into data
-- `ImageProcessing` – Apply image transformations
-- `ImageCaching` – Store images into a memory cache
-
-The entire configuration is described by the `ImagePipeline.Configuration` struct. To create a pipeline with a custom configuration either call the `ImagePipeline(configuration:)` initializer or use the convenience one:
-
-```swift
-let pipeline = ImagePipeline {
- $0.dataLoader = ...
- $0.dataLoadingQueue = ...
- $0.imageCache = ...
- ...
-}
-```
-
-And then set the new pipeline as default:
-
-```swift
-ImagePipeline.shared = pipeline
-```
-
-### Default Image Pipeline
-
-The default image pipeline is initialized with the following dependencies:
-
-```swift
-// Shared image cache with a size limit of ~20% of available RAM.
-imageCache = ImageCache.shared
-
-// Data loader with a default `URLSessionConfiguration` and a custom `URLCache`
-// with memory capacity 0, and disk capacity 150 MB.
-dataLoader = DataLoader()
-
-// Custom aggressive disk cache is disabled by default.
-dataCache = nil
-
-// By default uses the decoder from the global registry and the default encoder.
-makeImageDecoder = { context in ImageDecoderRegistry.shared.decoder(for: context) }
-makeImageEncoder = { _ in ImageEncoder() }
-```
-
-Each operation in the pipeline runs on a dedicated queue:
-
-```swift
-dataLoadingQueue.maxConcurrentOperationCount = 6
-dataCachingQueue.maxConcurrentOperationCount = 2
-imageDecodingQueue.maxConcurrentOperationCount = 1
-imageEncodingQueue.maxConcurrentOperationCount = 1
-imageProcessingQueue.maxConcurrentOperationCount = 2
-imageDecompressingQueue.maxConcurrentOperationCount = 2
-```
-
-There is a list of pipeline settings which you can tweak:
-
-```swift
-// Automatically decompress images in the background by default.
-isDecompressionEnabled = true
-
-// Configure which images to store in the custom disk cache.
-isDataCachingForOriginalImageDataEnabled = true
-isDataCachingForProcessedImagesEnabled = false
-
-// Avoid doing any duplicated work when loading or processing images.
-isDeduplicationEnabled = true
-
-// Rate limit the requests to prevent trashing of the subsystems.
-isRateLimiterEnabled = true
-
-// Progressive decoding is an opt-in feature because it is resource intensive.
-isProgressiveDecodingEnabled = false
-
-// If the data task is terminated (either because of a failure or a
-// cancellation) and the image was partially loaded, the next load will
-// resume where it was left off.
-isResumableDataEnabled = true
-```
-
-And also a few global options shared between all pipelines:
-
-```swift
-ImagePipeline.Configuration.isAnimatedImageDataEnabled = false
-
-// Enable to start using `os_signpost` to monitor the pipeline
-// performance using Instruments.
-ImagePipeline.Configuration.isSignpostLoggingEnabled = false
-```
-
-
-
-# Caching
-
-### LRU Memory Cache
-
-Nuke's default `ImagePipeline` has two cache layers.
-
-First, there is a memory cache for storing processed images which are ready for display.
-
-```swift
-// Configure cache
-ImageCache.shared.costLimit = 1024 * 1024 * 100 // 100 MB
-ImageCache.shared.countLimit = 100
-ImageCache.shared.ttl = 120 // Invalidate image after 120 sec
-
-// Read and write images
-let request = ImageRequest(url: url)
-ImageCache.shared[request] = image
-let image = ImageCache.shared[request]
-
-// Clear cache
-ImageCache.shared.removeAll()
-```
-
-`ImageCache` uses the [LRU](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)) algorithm – least recently used entries are removed first during the sweep.
-
-### HTTP Disk Cache
-
-Unprocessed image data is stored with `URLCache`.
-
-```swift
-// Configure cache
-DataLoader.sharedUrlCache.diskCapacity = 100
-DataLoader.sharedUrlCache.memoryCapacity = 0
-
-// Read and write responses
-let request = ImageRequest(url: url)
-let _ = DataLoader.sharedUrlCache.cachedResponse(for: request.urlRequest)
-DataLoader.sharedUrlCache.removeCachedResponse(for: request.urlRequest)
-
-// Clear cache
-DataLoader.sharedUrlCache.removeAllCachedResponses()
-```
-
-### Aggressive LRU Disk Cache
-
-If HTTP caching is not your cup of tea, you can try using a custom LRU disk cache for fast and reliable *aggressive* data caching (ignores [HTTP cache control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control)). You can enable it using the pipeline configuration.
-
-```swift
-ImagePipeline {
- $0.dataCache = try! DataCache(name: "com.myapp.datacache")
-
- // Also consider disabling the native HTTP cache, see `DataLoader`.
-}
-```
-
-By default, the pipeline stores only the original image data. To store the processed images enable `isDataCachingForProcessedImagesEnabled` and also consider disabling `isDataCachingForOriginalImageDataEnabled`. Every intermediate processed image will be stored in cache. So in the following scenario, there are going to be two entries in the disk cache (three if original image cache is also enabled):
-
-```swift
-let request = ImageRequest(url: url, processors: [
- ImageProcessor.Resize(size: imageView.bounds.size),
- ImageProcessor.CoreImageFilter(name: "CISepiaTone")
-])
-```
-
-To avoid storing unwanted images, compose the processors, `ImageProcessor.Composition` is an easy way to do it.
-
-
-
-# Advanced Features
-
-### Image Preheating
-
-Prefetching images in advance can dramatically improve your app's user experience.
-
-```swift
-let preheater = ImagePreheater()
-preheater.startPreheating(with: urls)
-
-// Cancels all of the preheating tasks created for the given requests.
-preheater.stopPreheating(with: urls)
-```
-
-Keep in mind that prefetching takes up users' data and puts extra pressure on CPU and memory. To reduce the CPU and memory usage, you have an option to choose only the disk cache as a prefetching destination:
-
-```swift
-// The preheater with `.diskCache` destination will skip image data decoding
-// entirely to reduce CPU and memory usage. It will still load the image data
-// and store it in disk caches to be used later.
-let preheater = ImagePreheater(destination: .diskCache)
-```
-
-> On iOS, you can use [prefetching APIs](https://developer.apple.com/reference/uikit/uitableviewdatasourceprefetching) in combination with `ImagePreheater` to automate the process.
-
-### Progressive Decoding
-
-To enable progressive image decoding set `isProgressiveDecodingEnabled` configuration option to `true`.
-
-
-
-```swift
-let pipeline = ImagePipeline {
- $0.isProgressiveDecodingEnabled = true
-}
-```
-
-And that's it, the pipeline will automatically do the right thing and deliver the progressive scans via `progress` closure as they arrive:
-
-```swift
-let imageView = UIImageView()
-let task = ImagePipeline.shared.loadImage(
- with: url,
- progress: { response, _, _ in
- if let response = response {
- imageView.image = response.image
- }
- },
- completion: { result in
- // Display the final image
- }
-)
-```
-
-### Animated Images
-
-To enable animated image support, set `ImagePipeline.Configuration.isAnimatedImageDataEnabled` to `true`. If enabled, Nuke will attach `animatedImageData` to the downloaded animated images. You going to need data to render the images.
-
-There is no built-in way to render animated images, but there are multiple options available.
-
-**Option 1**. Install [FLAnimatedImage Plugin](https://github.com/kean/Nuke-FLAnimatedImage-Plugin) and follow the instructions.
-
-**Option 2**. Install [Gifu](https://github.com/kaishin/Gifu) directly. To configure Gifu to work with Nuke, all you need to do is add these lines in your project:
-
-```swift
-ImagePipeline.Configuration.isAnimatedImageDataEnabled = true
-
-extension Gifu.GIFImageView {
- public override func nuke_display(image: Image?) {
- prepareForReuse()
- if let data = image?.animatedImageData {
- animate(withGIFData: data)
- } else {
- self.image = image
- }
- }
-}
-```
-
-You can now start using Gifu.GIFImageView:
-
-```swift
-let view = Gifu.GIFImageView()
-Nuke.loadImage(with: URL(string: "http://.../cat.gif")!, into: view)
-```
-
-> `GIF` is not the most efficient format for transferring and displaying animated images. The current best practice is to [use short videos instead of GIFs](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/replace-animated-gifs-with-video/) (e.g. `MP4`, `WebM`). There is a PoC available in the demo project which uses Nuke to load, cache and display an `MP4` video.
-
-### WebP
-
-WebP support is provided by [Nuke WebP Plugin](https://github.com/ryokosuge/Nuke-WebP-Plugin) built by [Ryo Kosuge](https://github.com/ryokosuge). Please follow the instructions from the repo.
-
-### RxNuke
-
-[RxNuke](https://github.com/kean/RxNuke) adds [RxSwift](https://github.com/ReactiveX/RxSwift) extensions for Nuke and enables common use cases: [Going from low to high resolution](https://github.com/kean/RxNuke#going-from-low-to-high-resolution) | [Loading the first available image](https://github.com/kean/RxNuke#loading-the-first-available-image) | [Showing stale image while validating it](https://github.com/kean/RxNuke#showing-stale-image-while-validating-it) | [Load multiple images, display all at once](https://github.com/kean/RxNuke#load-multiple-images-display-all-at-once) | [Auto retry on failures](https://github.com/kean/RxNuke#auto-retry) | [And more](https://github.com/kean/RxNuke#use-cases)
-
-To get a taste of what you can do with this extension, take a look at how easy it is to load the low resolution image first and then switch to high resolution:
-
-```swift
-let pipeline = ImagePipeline.shared
-Observable.concat(pipeline.loadImage(with: lowResUrl).orEmpty,
- pipeline.loadImage(with: highResUtl).orEmpty)
- .subscribe(onNext: { imageView.image = $0 })
- .disposed(by: disposeBag)
-```
-
-### Combine
-
-[ImagePublisher](https://github.com/kean/ImagePublisher) adds Combine publishers for Nuke and, just like [RxNuke](https://github.com/kean/RxNuke), enables a variety of powerful use cases.
-
-
-
-
-# Image Pipeline Overview
-
-This section describes in detail what happens when you perform a call like `Nuke.loadImage(with: url, into: view)`.
-
-> As a visual aid, use this [Block Diagram](https://github.com/kean/Nuke/blob/8.0/Documentation/Assets/image-pipeline.svg).
-
-First, Nuke synchronously checks if the image is stored in the memory cache. If the image is not in memory, Nuke calls `pipeline.loadImage(with: request)`.
-
-The pipeline first checks if the image or image data exists in any of its caches. It checks if the processed image exists in the memory cache, then if the processed image data exists in the custom data cache (disabled by default), then if the data cache contains the original image data. Only if there is no cached data, the pipeline will start loading the data. When the data is loaded the pipeline decodes it, applies the processors, and decompresses the image in the background.
-
-### Data Loading and Caching
-
-A `DataLoader` class uses [`URLSession`](https://developer.apple.com/reference/foundation/nsurlsession) to load image data. The data is cached on disk using [`URLCache`](https://developer.apple.com/reference/foundation/urlcache), which by default is initialized with memory capacity of 0 MB (only stores processed images in memory) and disk capacity of 150 MB.
-
-> See [Image Caching Guide](https://kean.github.io/post/image-caching) to learn more about HTTP cache.
-
-The `URLSession` class natively supports the following URL schemes: `data`, `file`, `ftp`, `http`, and `https`.
-
-Most developers either implement their own networking layer or use a third-party framework. Nuke supports both of these workflows. You can integrate your custom networking layer by implementing `DataLoading` protocol.
-
-> See [Third Party Libraries](https://github.com/kean/Nuke/blob/8.0/Documentation/Guides/Third%20Party%20Libraries.md#using-other-caching-libraries) guide to learn more. See also [Alamofire Plugin](https://github.com/kean/Nuke-Alamofire-Plugin).
-
-### Resumable Downloads
-
-If the data task is terminated (either because of a failure or a cancelation) and the image was partially loaded, the next load will resume where it was left off. Resumable downloads require the server to support [HTTP Range Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests). Nuke supports both validators (`ETag` and `Last-Modified`). The resumable downloads are enabled by default.
-
-### Memory Cache
-
-The processed images are stored in a fast in-memory cache (`ImageCache`). It uses [LRU (least recently used)](https://en.wikipedia.org/wiki/Cache_algorithms#Examples) replacement algorithm and has a limit of ~20% of available RAM. `ImageCache` automatically evicts images on memory warnings and removes a portion of its contents when the application enters background mode.
-
-### Deduplication
-
-The pipeline avoids doing any duplicated work when loading images. For example, let's take these two requests:
-
-```swift
-let url = URL(string: "http://example.com/image")
-pipeline.loadImage(with: ImageRequest(url: url, processors: [
- ImageProcessor.Resize(size: CGSize(width: 44, height: 44)),
- ImageProcessor.GaussianBlur(radius: 8)
-]))
-pipeline.loadImage(with: ImageRequest(url: url, processors: [
- ImageProcessor.Resize(size: CGSize(width: 44, height: 44))
-]))
-```
-
-Nuke will load the data only once, resize the image once and blur it also only once. There is no duplicated work done. The work only gets cancelled when all the registered requests are, and the priority is based on the highest priority of the registered requests.
-
-> Deduplication can be disabled using `isDeduplicationEnabled` configuration option.
-
-### Performance
-
-
-
-Nuke is tuned to do as little work on the main thread as possible. It uses multiple optimization techniques to achieve that: reducing the number of allocations, reducing dynamic dispatch, CoW, etc.
-
-Nuke is fully asynchronous and performs well under stress. `ImagePipeline` schedules its operations on dedicated queues. Each queue limits the number of concurrent tasks, respects the request priorities, and cancels the work as soon as possible. Under the extreme load, `ImagePipeline` will also rate limit the requests to prevent saturation of the underlying systems.
-
-If you want to see how the system behaves, how long each operation takes, and how many are performed in parallel, enable the `isSignpostLoggingEnabled` option and use the `os_signpost` Instrument. For more information see [Apple Documentation: Logging](https://developer.apple.com/documentation/os/logging) and [WWDC 2018: Measuring Performance Using Logging](https://developer.apple.com/videos/play/wwdc2018/405/).
-
-
-### Extensions
-
-There is a variety of extensions available for Nuke:
-
-|Name|Description|
-|--|--|
-|[**RxNuke**](https://github.com/kean/RxNuke)|[RxSwift](https://github.com/ReactiveX/RxSwift) extensions for Nuke with examples of common use cases solved by Rx|
-|[**FetchImage**](https://github.com/kean/FetchImage)|SwiftUI integration|
-|[**ImagePublisher**](https://github.com/kean/ImagePublisher)|Combine publishers for Nuke|
-|[**Alamofire Plugin**](https://github.com/kean/Nuke-Alamofire-Plugin)|Replace networking layer with [Alamofire](https://github.com/Alamofire/Alamofire) and combine the power of both frameworks|
-|[**WebP Plugin**](https://github.com/ryokosuge/Nuke-WebP-Plugin)| **[Community]** [WebP](https://developers.google.com/speed/webp/) support, built by [Ryo Kosuge](https://github.com/ryokosuge)|
-|[**Gifu Plugin**](https://github.com/kean/Nuke-Gifu-Plugin)|Use [Gifu](https://github.com/kaishin/Gifu) to load and display animated GIFs|
-|[**FLAnimatedImage Plugin**](https://github.com/kean/Nuke-AnimatedImage-Plugin)|Use [FLAnimatedImage](https://github.com/Flipboard/FLAnimatedImage) to load and display [animated GIFs]((https://www.youtube.com/watch?v=fEJqQMJrET4))|
-
-
-
-
-# Contribution
-
-[Nuke's roadmap](https://trello.com/b/Us4rHryT/nuke) is managed in Trello and is publicly available. If you'd like to contribute, please feel free to create a PR.
-
-
-# Requirements
-
-| Nuke | Swift | Xcode | Platforms |
-|---------------|-----------------|-----------------|---------------------------------------------------|
-| Nuke 8.0 | Swift 5.0 | Xcode 10.2 | iOS 10.0 / watchOS 3.0 / macOS 10.12 / tvOS 10.0 |
-| Nuke 7.6 | Swift 4.2 | Xcode 10.1 | iOS 10.0 / watchOS 3.0 / macOS 10.12 / tvOS 10.0 |
-| Nuke 7.2 | Swift 4.0 | Xcode 9.2 | iOS 9.0 / watchOS 2.0 / macOS 10.10 / tvOS 9.0 |
-
-# License
-
-Nuke is available under the MIT license. See the LICENSE file for more info.
diff --git a/Pods/Nuke/Sources/DataCache.swift b/Pods/Nuke/Sources/DataCache.swift
deleted file mode 100644
index ead2ae5..0000000
--- a/Pods/Nuke/Sources/DataCache.swift
+++ /dev/null
@@ -1,448 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-// MARK: - DataCaching
-
-/// Data cache.
-///
-/// - warning: The implementation must be thread safe.
-public protocol DataCaching {
- /// Retrieves data from cache for the given key.
- func cachedData(for key: String) -> Data?
-
- /// Stores data for the given key.
- /// - note: The implementation must return immediately and store data
- /// asynchronously.
- func storeData(_ data: Data, for key: String)
-}
-
-// MARK: - DataCache
-
-/// Data cache backed by a local storage.
-///
-/// The DataCache uses LRU cleanup policy (least recently used items are removed
-/// first). The elements stored in the cache are automatically discarded if
-/// either *cost* or *count* limit is reached. The sweeps are performed periodically.
-///
-/// DataCache always writes and removes data asynchronously. It also allows for
-/// reading and writing data in parallel. This is implemented using a "staging"
-/// area which stores changes until they are flushed to disk:
-///
-/// // Schedules data to be written asynchronously and returns immediately
-/// cache[key] = data
-///
-/// // The data is returned from the staging area
-/// let data = cache[key]
-///
-/// // Schedules data to be removed asynchronously and returns immediately
-/// cache[key] = nil
-///
-/// // Data is nil
-/// let data = cache[key]
-///
-/// Thread-safe.
-///
-/// - warning: It's possible to have more than one instance of `DataCache` with
-/// the same `path` but it is not recommended.
-public final class DataCache: DataCaching {
- /// A cache key.
- public typealias Key = String
-
- /// The maximum number of items. `1000` by default.
- ///
- /// Changes tos `countLimit` will take effect when the next LRU sweep is run.
- public var countLimit: Int = 1000
-
- /// Size limit in bytes. `100 Mb` by default.
- ///
- /// Changes to `sizeLimit` will take effect when the next LRU sweep is run.
- public var sizeLimit: Int = 1024 * 1024 * 100
-
- /// When performing a sweep, the cache will remote entries until the size of
- /// the remaining items is lower than or equal to `sizeLimit * trimRatio` and
- /// the total count is lower than or equal to `countLimit * trimRatio`. `0.7`
- /// by default.
- var trimRatio = 0.7
-
- /// The path for the directory managed by the cache.
- public let path: URL
-
- /// The number of seconds between each LRU sweep. 30 by default.
- /// The first sweep is performed right after the cache is initialized.
- ///
- /// Sweeps are performed in a background and can be performed in parallel
- /// with reading.
- public var sweepInterval: TimeInterval = 30
-
- /// The delay after which the initial sweep is performed. 10 by default.
- /// The initial sweep is performed after a delay to avoid competing with
- /// other subsystems for the resources.
- private var initialSweepDelay: TimeInterval = 15
-
- // Staging
- private let lock = NSLock()
- private var staging = Staging()
-
- /* testable */ let wqueue = DispatchQueue(label: "com.github.kean.Nuke.DataCache.WriteQueue", target: .global(qos: .utility))
-
- /// A function which generates a filename for the given key. A good candidate
- /// for a filename generator is a _cryptographic_ hash function like SHA1.
- ///
- /// The reason why filename needs to be generated in the first place is
- /// that filesystems have a size limit for filenames (e.g. 255 UTF-8 characters
- /// in AFPS) and do not allow certain characters to be used in filenames.
- public typealias FilenameGenerator = (_ key: String) -> String?
-
- private let filenameGenerator: FilenameGenerator
-
- /// Creates a cache instance with a given `name`. The cache creates a directory
- /// with the given `name` in a `.cachesDirectory` in `.userDomainMask`.
- /// - parameter filenameGenerator: Generates a filename for the given URL.
- /// The default implementation generates a filename using SHA1 hash function.
- public convenience init(name: String,
- filenameGenerator: @escaping (String) -> String? = DataCache.filename(for:)) throws {
- guard let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
- throw NSError(domain: NSCocoaErrorDomain, code: NSFileNoSuchFileError, userInfo: nil)
- }
- try self.init(path: root.appendingPathComponent(name, isDirectory: true), filenameGenerator: filenameGenerator)
- }
-
- /// Creates a cache instance with a given path.
- /// - parameter filenameGenerator: Generates a filename for the given URL.
- /// The default implementation generates a filename using SHA1 hash function.
- public init(path: URL, filenameGenerator: @escaping (String) -> String? = DataCache.filename(for:)) throws {
- self.path = path
- self.filenameGenerator = filenameGenerator
- try self.didInit()
- }
-
- /// A `FilenameGenerator` implementation which uses SHA1 hash function to
- /// generate a filename from the given key.
- public static func filename(for key: String) -> String? {
- return key.sha1
- }
-
- private func didInit() throws {
- try FileManager.default.createDirectory(at: path, withIntermediateDirectories: true, attributes: nil)
- wqueue.asyncAfter(deadline: .now() + initialSweepDelay) { [weak self] in
- self?._performAndScheduleSweep()
- }
- }
-
- // MARK: DataCaching
-
- /// Retrieves data for the given key. The completion will be called
- /// syncrhonously if there is no cached data for the given key.
- public func cachedData(for key: Key) -> Data? {
- lock.lock()
-
- if let change = staging.change(for: key) {
- lock.unlock()
- switch change {
- case let .add(data):
- return data
- case .remove:
- return nil
- }
- }
-
- lock.unlock()
-
- guard let url = self.url(for: key) else {
- return nil
- }
- return try? Data(contentsOf: url)
- }
-
- /// Stores data for the given key. The method returns instantly and the data
- /// is written asynchronously.
- public func storeData(_ data: Data, for key: Key) {
- lock.sync {
- let change = staging.add(data: data, for: key)
- wqueue.async {
- if let url = self.url(for: key) {
- do {
- try data.write(to: url)
- } catch let error as NSError {
- guard error.code == CocoaError.fileNoSuchFile.rawValue && error.domain == CocoaError.errorDomain else { return }
- try? FileManager.default.createDirectory(at: self.path, withIntermediateDirectories: true, attributes: nil)
- try? data.write(to: url) // re-create a directory and try again
- }
- }
- self.lock.sync {
- self.staging.flushed(change)
- }
- }
- }
- }
-
- /// Removes data for the given key. The method returns instantly, the data
- /// is removed asynchronously.
- public func removeData(for key: Key) {
- lock.sync {
- let change = staging.removeData(for: key)
- wqueue.async {
- if let url = self.url(for: key) {
- try? FileManager.default.removeItem(at: url)
- }
- self.lock.sync {
- self.staging.flushed(change)
- }
- }
- }
- }
-
- /// Removes all items. The method returns instantly, the data is removed
- /// asynchronously.
- public func removeAll() {
- lock.sync {
- let change = staging.removeAll()
- wqueue.async {
- try? FileManager.default.removeItem(at: self.path)
- try? FileManager.default.createDirectory(at: self.path, withIntermediateDirectories: true, attributes: nil)
- self.lock.sync {
- self.staging.flushed(change)
- }
- }
- }
- }
-
- /// Accesses the data associated with the given key for reading and writing.
- ///
- /// When you assign a new data for a key and the key already exists, the cache
- /// overwrites the existing data.
- ///
- /// When assigning or removing data, the subscript adds a requested operation
- /// in a staging area and returns immediately. The staging area allows for
- /// reading and writing data in parallel.
- ///
- /// // Schedules data to be written asynchronously and returns immediately
- /// cache[key] = data
- ///
- /// // The data is returned from the staging area
- /// let data = cache[key]
- ///
- /// // Schedules data to be removed asynchronously and returns immediately
- /// cache[key] = nil
- ///
- /// // Data is nil
- /// let data = cache[key]
- ///
- public subscript(key: Key) -> Data? {
- get {
- return cachedData(for: key)
- }
- set {
- if let data = newValue {
- storeData(data, for: key)
- } else {
- removeData(for: key)
- }
- }
- }
-
- // MARK: Managing URLs
-
- /// Uses the `FilenameGenerator` that the cache was initialized with to
- /// generate and return a filename for the given key.
- public func filename(for key: Key) -> String? {
- return filenameGenerator(key)
- }
-
- /* testable */ func url(for key: Key) -> URL? {
- guard let filename = self.filename(for: key) else {
- return nil
- }
- return self.path.appendingPathComponent(filename, isDirectory: false)
- }
-
- // MARK: Flush Changes
-
- /// Synchronously waits on the caller's thread until all outstanding disk IO
- /// operations are finished.
- public func flush() {
- wqueue.sync {}
- }
-
- // MARK: Sweep
-
- private func _performAndScheduleSweep() {
- _sweep()
- wqueue.asyncAfter(deadline: .now() + sweepInterval) { [weak self] in
- self?._performAndScheduleSweep()
- }
- }
-
- /// Schedules a cache sweep to be performed immediately.
- public func sweep() {
- wqueue.async {
- self._sweep()
- }
- }
-
- /// Discards the least recently used items first.
- private func _sweep() {
- var items = contents(keys: [.contentAccessDateKey, .totalFileAllocatedSizeKey])
- guard !items.isEmpty else {
- return
- }
- var size = items.reduce(0) { $0 + ($1.meta.totalFileAllocatedSize ?? 0) }
- var count = items.count
- let sizeLimit = self.sizeLimit / Int(1 / trimRatio)
- let countLimit = self.countLimit / Int(1 / trimRatio)
-
- guard size > sizeLimit || count > countLimit else {
- return // All good, no need to perform any work.
- }
-
- // Most recently accessed items first
- let past = Date.distantPast
- items.sort { // Sort in place
- ($0.meta.contentAccessDate ?? past) > ($1.meta.contentAccessDate ?? past)
- }
-
- // Remove the items until it satisfies both size and count limits.
- while (size > sizeLimit || count > countLimit), let item = items.popLast() {
- size -= (item.meta.totalFileAllocatedSize ?? 0)
- count -= 1
- try? FileManager.default.removeItem(at: item.url)
- }
- }
-
- // MARK: Contents
-
- struct Entry {
- let url: URL
- let meta: URLResourceValues
- }
-
- func contents(keys: [URLResourceKey] = []) -> [Entry] {
- guard let urls = try? FileManager.default.contentsOfDirectory(at: path, includingPropertiesForKeys: keys, options: .skipsHiddenFiles) else {
- return []
- }
- let keys = Set(keys)
- return urls.compactMap {
- guard let meta = try? $0.resourceValues(forKeys: keys) else {
- return nil
- }
- return Entry(url: $0, meta: meta)
- }
- }
-
- // MARK: Inspection
-
- /// The total number of items in the cache.
- /// - warning: Requires disk IO, avoid using from the main thread.
- public var totalCount: Int {
- return contents().count
- }
-
- /// The total file size of items written on disk.
- ///
- /// Uses `URLResourceKey.fileSizeKey` to calculate the size of each entry.
- /// The total allocated size (see `totalAllocatedSize`. on disk might
- /// actually be bigger.
- ///
- /// - warning: Requires disk IO, avoid using from the main thread.
- public var totalSize: Int {
- return contents(keys: [.fileSizeKey]).reduce(0) {
- $0 + ($1.meta.fileSize ?? 0)
- }
- }
-
- /// The total file allocated size of all the items written on disk.
- ///
- /// Uses `URLResourceKey.totalFileAllocatedSizeKey`.
- ///
- /// - warning: Requires disk IO, avoid using from the main thread.
- public var totalAllocatedSize: Int {
- return contents(keys: [.totalFileAllocatedSizeKey]).reduce(0) {
- $0 + ($1.meta.totalFileAllocatedSize ?? 0)
- }
- }
-
- // MARK: - Staging
-
- /// DataCache allows for parallel reads and writes. This is made possible by
- /// DataCacheStaging.
- ///
- /// For example, when the data is added in cache, it is first added to staging
- /// and is removed from staging only after data is written to disk. Removal works
- /// the same way.
- private final class Staging {
- private var changes = [String: Change]()
- private var changeRemoveAll: ChangeRemoveAll?
-
- struct ChangeRemoveAll {
- let id: Int
- }
-
- struct Change {
- let key: String
- let id: Int
- let type: ChangeType
- }
-
- enum ChangeType {
- case add(Data)
- case remove
- }
-
- private var nextChangeId = 0
-
- // MARK: Changes
-
- func change(for key: String) -> ChangeType? {
- if let change = changes[key] {
- return change.type
- }
- if changeRemoveAll != nil {
- return .remove
- }
- return nil
- }
-
- // MARK: Register Changes
-
- func add(data: Data, for key: String) -> Change {
- return makeChange(.add(data), for: key)
- }
-
- func removeData(for key: String) -> Change {
- return makeChange(.remove, for: key)
- }
-
- private func makeChange(_ type: ChangeType, for key: String) -> Change {
- nextChangeId += 1
- let change = Change(key: key, id: nextChangeId, type: type)
- changes[key] = change
- return change
- }
-
- func removeAll() -> ChangeRemoveAll {
- nextChangeId += 1
- let change = ChangeRemoveAll(id: nextChangeId)
- changeRemoveAll = change
- changes.removeAll()
- return change
- }
-
- // MARK: Flush Changes
-
- func flushed(_ change: Change) {
- if let index = changes.index(forKey: change.key),
- changes[index].value.id == change.id {
- changes.remove(at: index)
- }
- }
-
- func flushed(_ change: ChangeRemoveAll) {
- if changeRemoveAll?.id == change.id {
- changeRemoveAll = nil
- }
- }
- }
-}
diff --git a/Pods/Nuke/Sources/DataLoader.swift b/Pods/Nuke/Sources/DataLoader.swift
deleted file mode 100644
index 65abc4b..0000000
--- a/Pods/Nuke/Sources/DataLoader.swift
+++ /dev/null
@@ -1,215 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-public protocol Cancellable: AnyObject {
- func cancel()
-}
-
-public protocol DataLoading {
- /// - parameter didReceiveData: Can be called multiple times if streaming
- /// is supported.
- /// - parameter completion: Must be called once after all (or none in case
- /// of an error) `didReceiveData` closures have been called.
- func loadData(with request: URLRequest,
- didReceiveData: @escaping (Data, URLResponse) -> Void,
- completion: @escaping (Error?) -> Void) -> Cancellable
-}
-
-extension URLSessionTask: Cancellable {}
-
-/// Provides basic networking using `URLSession`.
-public final class DataLoader: DataLoading, _DataLoaderObserving {
- public let session: URLSession
- private let impl = _DataLoader()
-
- public var observer: DataLoaderObserving?
-
- deinit {
- session.invalidateAndCancel()
- }
-
- /// Initializes `DataLoader` with the given configuration.
- /// - parameter configuration: `URLSessionConfiguration.default` with
- /// `URLCache` with 0 MB memory capacity and 150 MB disk capacity.
- public init(configuration: URLSessionConfiguration = DataLoader.defaultConfiguration,
- validate: @escaping (URLResponse) -> Swift.Error? = DataLoader.validate) {
- let queue = OperationQueue()
- queue.maxConcurrentOperationCount = 1
- self.session = URLSession(configuration: configuration, delegate: impl, delegateQueue: queue)
- self.impl.validate = validate
- self.impl.observer = self
- }
-
- /// Returns a default configuration which has a `sharedUrlCache` set
- /// as a `urlCache`.
- public static var defaultConfiguration: URLSessionConfiguration {
- let conf = URLSessionConfiguration.default
- conf.urlCache = DataLoader.sharedUrlCache
- return conf
- }
-
- /// Validates `HTTP` responses by checking that the status code is 2xx. If
- /// it's not returns `DataLoader.Error.statusCodeUnacceptable`.
- public static func validate(response: URLResponse) -> Swift.Error? {
- guard let response = response as? HTTPURLResponse else {
- return nil
- }
- return (200..<300).contains(response.statusCode) ? nil : Error.statusCodeUnacceptable(response.statusCode)
- }
-
- #if !os(macOS) && !targetEnvironment(macCatalyst)
- private static let cachePath = "com.github.kean.Nuke.Cache"
- #else
- private static let cachePath: String = {
- let cachePaths = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true)
- if let cachePath = cachePaths.first, let identifier = Bundle.main.bundleIdentifier {
- return cachePath.appending("/" + identifier)
- }
-
- return ""
- }()
- #endif
-
- /// Shared url cached used by a default `DataLoader`. The cache is
- /// initialized with 0 MB memory capacity and 150 MB disk capacity.
- public static let sharedUrlCache: URLCache = {
- let diskCapacity = 150 * 1024 * 1024 // 150 MB
- #if targetEnvironment(macCatalyst)
- return URLCache(memoryCapacity: 0, diskCapacity: diskCapacity, directory: URL(fileURLWithPath: cachePath))
- #else
- return URLCache(memoryCapacity: 0, diskCapacity: diskCapacity, diskPath: cachePath)
- #endif
- }()
-
- public func loadData(with request: URLRequest,
- didReceiveData: @escaping (Data, URLResponse) -> Void,
- completion: @escaping (Swift.Error?) -> Void) -> Cancellable {
- return impl.loadData(with: request, session: session, didReceiveData: didReceiveData, completion: completion)
- }
-
- /// Errors produced by `DataLoader`.
- public enum Error: Swift.Error, CustomDebugStringConvertible {
- /// Validation failed.
- case statusCodeUnacceptable(Int)
-
- public var debugDescription: String {
- switch self {
- case let .statusCodeUnacceptable(code):
- return "Response status code was unacceptable: \(code.description)"
- }
- }
- }
-
- // MARK: _DataLoaderObserving
-
- func dataTask(_ dataTask: URLSessionDataTask, didReceiveEvent event: DataTaskEvent) {
- observer?.dataLoader(self, urlSession: session, dataTask: dataTask, didReceiveEvent: event)
- }
-}
-
-// Actual data loader implementation. Hide NSObject inheritance, hide
-// URLSessionDataDelegate conformance, and break retain cycle between URLSession
-// and URLSessionDataDelegate.
-private final class _DataLoader: NSObject, URLSessionDataDelegate {
- var validate: (URLResponse) -> Swift.Error? = DataLoader.validate
- private var handlers = [URLSessionTask: _Handler]()
- weak var observer: _DataLoaderObserving?
-
- /// Loads data with the given request.
- func loadData(with request: URLRequest,
- session: URLSession,
- didReceiveData: @escaping (Data, URLResponse) -> Void,
- completion: @escaping (Error?) -> Void) -> Cancellable {
- let task = session.dataTask(with: request)
- let handler = _Handler(didReceiveData: didReceiveData, completion: completion)
- session.delegateQueue.addOperation { // `URLSession` is configured to use this same queue
- self.handlers[task] = handler
- }
- task.resume()
- send(task, .resumed)
- return task
- }
-
- // MARK: URLSessionDelegate
-
- func urlSession(_ session: URLSession,
- dataTask: URLSessionDataTask,
- didReceive response: URLResponse,
- completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
- send(dataTask, .receivedResponse(response: response))
-
- guard let handler = handlers[dataTask] else {
- completionHandler(.cancel)
- return
- }
- if let error = validate(response) {
- handler.completion(error)
- completionHandler(.cancel)
- return
- }
- completionHandler(.allow)
- }
-
- func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
- assert(task is URLSessionDataTask)
- if let dataTask = task as? URLSessionDataTask {
- send(dataTask, .completed(error: error))
- }
-
- guard let handler = handlers[task] else {
- return
- }
- handlers[task] = nil
- handler.completion(error)
- }
-
- // MARK: URLSessionDataDelegate
-
- func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
- send(dataTask, .receivedData(data: data))
-
- guard let handler = handlers[dataTask], let response = dataTask.response else {
- return
- }
- // Don't store data anywhere, just send it to the pipeline.
- handler.didReceiveData(data, response)
- }
-
- // MARK: Internal
-
- private func send(_ dataTask: URLSessionDataTask, _ event: DataTaskEvent) {
- observer?.dataTask(dataTask, didReceiveEvent: event)
- }
-
- private final class _Handler {
- let didReceiveData: (Data, URLResponse) -> Void
- let completion: (Error?) -> Void
-
- init(didReceiveData: @escaping (Data, URLResponse) -> Void, completion: @escaping (Error?) -> Void) {
- self.didReceiveData = didReceiveData
- self.completion = completion
- }
- }
-}
-
-// MARK: - DataLoaderObserving
-
-public enum DataTaskEvent {
- case resumed
- case receivedResponse(response: URLResponse)
- case receivedData(data: Data)
- case completed(error: Error?)
-}
-
-/// Allows you to tap into internal events of the data loader. Events are
-/// delivered on the internal serial operation queue.
-public protocol DataLoaderObserving {
- func dataLoader(_ loader: DataLoader, urlSession: URLSession, dataTask: URLSessionDataTask, didReceiveEvent event: DataTaskEvent)
-}
-
-protocol _DataLoaderObserving: class {
- func dataTask(_ dataTask: URLSessionDataTask, didReceiveEvent event: DataTaskEvent)
-}
diff --git a/Pods/Nuke/Sources/Deprecated.swift b/Pods/Nuke/Sources/Deprecated.swift
deleted file mode 100644
index 2b2b17f..0000000
--- a/Pods/Nuke/Sources/Deprecated.swift
+++ /dev/null
@@ -1,287 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-// MARK: - ImageRequest (Deprecated)
-
-extension ImageRequest {
-
- @available(*, deprecated, message: "Please use `var processors: [ImageProcessing]` instead")
- public var processor: ImageProcessing? {
- get { return processors.first }
- set {
- guard let newValue = newValue else {
- processors = []
- return
- }
- processors = [newValue]
- }
- }
-
- @available(*, deprecated, message: "Please use `ImageRequestOptions` instead, it now contains all the advanced options")
- public var memoryCacheOptions: ImageRequestOptions.MemoryCacheOptions {
- get { return options.memoryCacheOptions }
- set { options.memoryCacheOptions = newValue }
- }
-
- @available(*, deprecated, message: "Please use `ImageRequestOptions` instead, it now contains all the advanced options")
- public var cacheKey: AnyHashable? {
- get { return options.cacheKey }
- set { options.cacheKey = newValue }
- }
-
- @available(*, deprecated, message: "Please use `ImageRequestOptions` instead, it now contains all the advanced options")
- public var loadKey: AnyHashable? {
- get { return options.loadKey }
- set { options.loadKey = newValue }
- }
-
- @available(*, deprecated, message: "Please use `ImageRequestOptions` instead, it now contains all the advanced options")
- public var userInfo: Any? {
- get { return options.userInfo }
- set { options.userInfo = newValue }
- }
-
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(url:processors:priority:options:)` instead")
- public init(url: URL, processor: ImageProcessing) {
- self = ImageRequest(url: url, processors: [processor])
- }
-
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(urlRequest:processors:priority:options:)` instead")
- public init(urlRequest: URLRequest, processor: ImageProcessing) {
- self = ImageRequest(urlRequest: urlRequest, processors: [processor])
- }
-}
-
-extension ImageRequest {
-
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(urlRequest:processors:priority:options:)` instead or set processors via new `var processors: [ImageProcessing]` property.")
- public mutating func process(with processor: ImageProcessing) {
- processors.append(processor)
- }
-
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(urlRequest:processors:priority:options:)` instead or set processors via new `var processors: [ImageProcessing]` property.")
- public func processed(with processor: ImageProcessing) -> ImageRequest {
- var request = self
- request.process(with: processor)
- return request
- }
-
- @available(*, deprecated, message: "Please use `ImageProcessor.Anonymous` instead. Key must also be a `String` now")
- public mutating func process(key: String, _ closure: @escaping (Image) -> Image?) {
- process(with: ImageProcessor.Anonymous(id: key, closure))
- }
-
- @available(*, deprecated, message: "Please use `ImageProcessor.Anonymous` instead. Key must also be a `String` now")
- public func processed(key: String, _ closure: @escaping (Image) -> Image?) -> ImageRequest {
- return processed(with: ImageProcessor.Anonymous(id: key, closure))
- }
-}
-
-#if !os(macOS)
-import UIKit
-
-extension ImageRequest {
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(url:processors:priority:options:)` with `ImageProcessor.Resize` instead. Target size for `ImageProcessor.Resize` is in points by default, not pixels! For more info see https://github.com/kean/Nuke/pull/229.")
- public init(url: URL, targetSize: CGSize, contentMode: ImageDecompressor.ContentMode, upscale: Bool = false) {
- self.init(url: url, processor: ImageDecompressor(targetSize: targetSize, contentMode: contentMode, upscale: upscale))
- }
-
- @available(*, deprecated, message: "Please use the new unified initializer `ImageRequest.init(urlRequest:processors:priority:options:)` with `ImageProcessor.Resize`instead. Target size for `ImageProcessor.Resize` is in points by default, not pixels! For more info see https://github.com/kean/Nuke/pull/229.")
- public init(urlRequest: URLRequest, targetSize: CGSize, contentMode: ImageDecompressor.ContentMode, upscale: Bool = false) {
- self.init(urlRequest: urlRequest, processor: ImageDecompressor(targetSize: targetSize, contentMode: contentMode, upscale: upscale))
- }
-}
-#endif
-
-// MARK: - ImageDecompressor (Deprecated)
-
-#if !os(macOS)
-import UIKit
-
-/// Decompresses and (optionally) scales down input images. Maintains
-/// original aspect ratio.
-///
-/// Decompressing compressed image formats (such as JPEG) can significantly
-/// improve drawing performance as it allows a bitmap representation to be
-/// created in a background rather than on the main thread.
-@available(*, deprecated, message: "Decompression now runs automatically after all processors were applied and only if still needed. To disable decompression use `ImagePipeline.Configuration.isDecompressionEnabled`. If you were using `ImageDecompressor` to resize image please use `ImageProcessor.Resize`. Please be aware that the target size for `ImageProcessor.Resize` is in points by default, not pixels like in `ImageDecompressor`! For more info see https://github.com/kean/Nuke/pull/229.")
-public struct ImageDecompressor: ImageProcessing {
- public var identifier: String {
- return resize.identifier
- }
-
- public var hashableIdentifier: AnyHashable {
- return resize.hashableIdentifier
- }
-
- /// An option for how to resize the image.
- public enum ContentMode {
- /// Scales the image so that it completely fills the target size.
- /// Doesn't clip images.
- case aspectFill
-
- /// Scales the image so that it fits the target size.
- case aspectFit
- }
-
- /// Size to pass to disable resizing.
- public static let MaximumSize = CGSize(
- width: CGFloat.greatestFiniteMagnitude,
- height: CGFloat.greatestFiniteMagnitude
- )
-
- private let resize: ImageProcessor.Resize
-
- /// Initializes `Decompressor` with the given parameters.
- /// - parameter targetSize: Size in pixels. `MaximumSize` by default.
- /// - parameter contentMode: An option for how to resize the image
- /// to the target size. `.aspectFill` by default.
- public init(targetSize: CGSize = MaximumSize, contentMode: ContentMode = .aspectFill, upscale: Bool = false) {
- self.resize = ImageProcessor.Resize(size: targetSize, unit: .pixels, contentMode: .init(contentMode), upscale: upscale)
- }
-
- public func process(image: Image, context: ImageProcessingContext?) -> Image? {
- return resize.process(image: image, context: context)
- }
-
- /// Returns true if both have the same `targetSize` and `contentMode`.
- public static func == (lhs: ImageDecompressor, rhs: ImageDecompressor) -> Bool {
- return lhs.resize == rhs.resize
- }
-
- #if !os(watchOS)
- /// Returns target size in pixels for the given view. Takes main screen
- /// scale into the account.
- public static func targetSize(for view: UIView) -> CGSize { // in pixels
- let scale = UIScreen.main.scale
- let size = view.bounds.size
- return CGSize(width: size.width * scale, height: size.height * scale)
- }
- #endif
-}
-
-@available(*, deprecated)
-extension ImageProcessor.Resize.ContentMode {
- init(_ contentMode: ImageDecompressor.ContentMode) {
- switch contentMode {
- case .aspectFill: self = .aspectFill
- case .aspectFit: self = .aspectFit
- }
- }
-}
-
-#endif
-
-// MARK: - AnyImageProcessor (Deprecated)
-
-@available(*, deprecated, message: "The new `ImageProcessing` protocol now longer has Self requirement which were previously needed due to `Equatable`, `AnyImageProcessor` is no longer needed")
-public struct AnyImageProcessor {}
-
-// MARK: - ImageTaskMetrics (Deprecated)
-
-extension ImagePipeline {
- @available(*, deprecated, message: "Please use os_signposts instead. For more info see `ImagePipeline.Configuration.isSignpostLoggingEnabled`")
- public var didFinishCollectingMetrics: ((ImageTask, ImageTaskMetrics) -> Void)? {
- set {} // swiftlint:disable:this unused_setter_value
- get { return nil }
- }
-}
-
-@available(*, deprecated, message: "Please use os_signposts instead. For more info see `ImagePipeline.Configuration.isSignpostLoggingEnabled`")
-public struct ImageTaskMetrics: CustomDebugStringConvertible {
- public let taskId: Int
- public internal(set) var wasCancelled: Bool = false
- public internal(set) var session: SessionMetrics?
-
- public let startDate: Date
- public internal(set) var processStartDate: Date?
- public internal(set) var processEndDate: Date?
- public internal(set) var endDate: Date? // failed or completed
- public var totalDuration: TimeInterval? {
- guard let endDate = endDate else { return nil }
- return endDate.timeIntervalSince(startDate)
- }
-
- /// Returns `true` is the task wasn't the one that initiated image loading.
- public internal(set) var wasSubscibedToExistingSession: Bool = false
- public internal(set) var isMemoryCacheHit: Bool = false
-
- init(taskId: Int, startDate: Date) {
- self.taskId = taskId; self.startDate = startDate
- }
-
- public var debugDescription: String {
- return "Deprecated, please use os_signposts instead. For more info see `ImagePipeline.Configuration.isSignpostLoggingEnabled`"
- }
-
- public final class SessionMetrics: CustomDebugStringConvertible {
- public let sessionId: Int
- public internal(set) var wasCancelled: Bool = false
- public let startDate = Date()
-
- public internal(set) var checkDiskCacheStartDate: Date?
- public internal(set) var checkDiskCacheEndDate: Date?
-
- public internal(set) var loadDataStartDate: Date?
- public internal(set) var loadDataEndDate: Date?
-
- public internal(set) var decodeStartDate: Date?
- public internal(set) var decodeEndDate: Date?
-
- @available(*, deprecated, message: "Please use the same property on `ImageTaskMetrics` instead.")
- public internal(set) var processStartDate: Date?
-
- @available(*, deprecated, message: "Please use the same property on `ImageTaskMetrics` instead.")
- public internal(set) var processEndDate: Date?
-
- public internal(set) var endDate: Date? // failed or completed
- public var totalDuration: TimeInterval? {
- guard let endDate = endDate else { return nil }
- return endDate.timeIntervalSince(startDate)
- }
-
- public internal(set) var wasResumed: Bool?
- public internal(set) var resumedDataCount: Int?
- public internal(set) var serverConfirmedResume: Bool?
-
- public internal(set) var downloadedDataCount: Int?
- public var totalDownloadedDataCount: Int? {
- guard let downloaded = self.downloadedDataCount else { return nil }
- return downloaded + (resumedDataCount ?? 0)
- }
-
- init(sessionId: Int) { self.sessionId = sessionId }
-
- public var debugDescription: String {
- return "Deprecated, please use os_signposts instead. For more info see `ImagePipeline.Configuration.isSignpostLoggingEnabled`"
- }
- }
-}
-
-// MARK: - ImageTask (Deprecated)
-
-extension ImageTask {
- @available(*, deprecated, message: "Please use `var priority: ImageRequest.Priority`")
- public func setPriority(_ priority: ImageRequest.Priority) {
- self.priority = priority
- }
-}
-
-// MARK: - Image (Deprecated)
-
-// Deprecated in 8.4
-@available(*, deprecated, message: "Deprecated to avoid name clashes with SwiftUI. Please use `PlatformImage` instead.")
-public typealias Image = PlatformImage
-
-// MARK: - ImageProcessor.RoundedCorners.Border (Deprecated)
-
-// Deprecated in 8.4
-#if !os(macOS)
-public extension ImageProcessor.RoundedCorners {
- @available(*, deprecated, message: "Please use `ImageProcessor.Border` instead.")
- typealias Border = ImageProcessor.Border
-}
-#endif
diff --git a/Pods/Nuke/Sources/ImageCache.swift b/Pods/Nuke/Sources/ImageCache.swift
deleted file mode 100644
index de9df7f..0000000
--- a/Pods/Nuke/Sources/ImageCache.swift
+++ /dev/null
@@ -1,311 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-#if !os(macOS)
-import UIKit
-#else
-import Cocoa
-#endif
-
-/// In-memory image cache.
-///
-/// The implementation must be thread safe.
-public protocol ImageCaching: AnyObject {
- /// Returns the `ImageResponse` stored in the cache with the given request.
- func cachedResponse(for request: ImageRequest) -> ImageResponse?
-
- /// Stores the given `ImageResponse` in the cache using the given request.
- func storeResponse(_ response: ImageResponse, for request: ImageRequest)
-
- /// Remove the response for the given request.
- func removeResponse(for request: ImageRequest)
-}
-
-/// Convenience subscript.
-public extension ImageCaching {
- /// Accesses the image associated with the given request.
- subscript(request: ImageRequest) -> PlatformImage? {
- get {
- return cachedResponse(for: request)?.image
- }
- set {
- if let newValue = newValue {
- storeResponse(ImageResponse(image: newValue, urlResponse: nil, scanNumber: nil), for: request)
- } else {
- removeResponse(for: request)
- }
- }
- }
-}
-
-/// Memory cache with LRU cleanup policy (least recently used are removed first).
-///
-/// The elements stored in cache are automatically discarded if either *cost* or
-/// *count* limit is reached. The default cost limit represents a number of bytes
-/// and is calculated based on the amount of physical memory available on the
-/// device. The default cmount limit is set to `Int.max`.
-///
-/// `Cache` automatically removes all stored elements when it received a
-/// memory warning. It also automatically removes *most* of cached elements
-/// when the app enters background.
-public final class ImageCache: ImageCaching {
- private let impl: Cache
-
- /// The maximum total cost that the cache can hold.
- public var costLimit: Int {
- get { return impl.costLimit }
- set { impl.costLimit = newValue }
- }
-
- /// The maximum number of items that the cache can hold.
- public var countLimit: Int {
- get { return impl.countLimit }
- set { impl.countLimit = newValue }
- }
-
- /// Default TTL (time to live) for each entry. Can be used to make sure that
- /// the entries get validated at some point. `0` (never expire) by default.
- public var ttl: TimeInterval {
- get { return impl.ttl }
- set { impl.ttl = newValue }
- }
-
- /// The total cost of items in the cache.
- public var totalCost: Int {
- return impl.totalCost
- }
-
- /// The total number of items in the cache.
- public var totalCount: Int {
- return impl.totalCount
- }
-
- /// Shared `Cache` instance.
- public static let shared = ImageCache()
-
- /// Initializes `Cache`.
- /// - parameter costLimit: Default value representes a number of bytes and is
- /// calculated based on the amount of the phisical memory available on the device.
- /// - parameter countLimit: `Int.max` by default.
- public init(costLimit: Int = ImageCache.defaultCostLimit(), countLimit: Int = Int.max) {
- impl = Cache(costLimit: costLimit, countLimit: countLimit)
- }
-
- /// Returns a recommended cost limit which is computed based on the amount
- /// of the phisical memory available on the device.
- public static func defaultCostLimit() -> Int {
- let physicalMemory = ProcessInfo.processInfo.physicalMemory
- let ratio = physicalMemory <= (536_870_912 /* 512 Mb */) ? 0.1 : 0.2
- let limit = physicalMemory / UInt64(1 / ratio)
- return limit > UInt64(Int.max) ? Int.max : Int(limit)
- }
-
- /// Returns the `ImageResponse` stored in the cache with the given request.
- public func cachedResponse(for request: ImageRequest) -> ImageResponse? {
- return impl.value(forKey: request.makeCacheKeyForProcessedImage())
- }
-
- /// Stores the given `ImageResponse` in the cache using the given request.
- public func storeResponse(_ response: ImageResponse, for request: ImageRequest) {
- impl.set(response, forKey: request.makeCacheKeyForProcessedImage(), cost: self.cost(for: response.image))
- }
-
- /// Removes response stored with the given request.
- public func removeResponse(for request: ImageRequest) {
- impl.removeValue(forKey: request.makeCacheKeyForProcessedImage())
- }
-
- /// Removes all cached images.
- public func removeAll() {
- impl.removeAll()
- }
- /// Removes least recently used items from the cache until the total cost
- /// of the remaining items is less than the given cost limit.
- public func trim(toCost limit: Int) {
- impl.trim(toCost: limit)
- }
-
- /// Removes least recently used items from the cache until the total count
- /// of the remaining items is less than the given count limit.
- public func trim(toCount limit: Int) {
- impl.trim(toCount: limit)
- }
-
- /// Returns cost for the given image by approximating its bitmap size in bytes in memory.
- func cost(for image: PlatformImage) -> Int {
- let dataCost: Int
- if ImagePipeline.Configuration.isAnimatedImageDataEnabled {
- dataCost = image.animatedImageData?.count ?? 0
- } else {
- dataCost = 0
- }
-
- // bytesPerRow * height gives a rough estimation of how much memory
- // image uses in bytes. In practice this algorithm combined with a
- // concervative default cost limit works OK.
- guard let cgImage = image.cgImage else {
- return 1 + dataCost
- }
- return cgImage.bytesPerRow * cgImage.height + dataCost
- }
-}
-
-final class Cache {
- // Can't use `NSCache` because it is not LRU
-
- private var map = [Key: LinkedList.Node]()
- private let list = LinkedList()
- private let lock = NSLock()
-
- var costLimit: Int {
- didSet { lock.sync(_trim) }
- }
-
- var countLimit: Int {
- didSet { lock.sync(_trim) }
- }
-
- private(set) var totalCost = 0
- var ttl: TimeInterval = 0
-
- var totalCount: Int {
- return map.count
- }
-
- init(costLimit: Int, countLimit: Int) {
- self.costLimit = costLimit
- self.countLimit = countLimit
- #if os(iOS) || os(tvOS)
- let center = NotificationCenter.default
- center.addObserver(self, selector: #selector(removeAll),
- name: UIApplication.didReceiveMemoryWarningNotification,
- object: nil)
- center.addObserver(self, selector: #selector(didEnterBackground),
- name: UIApplication.didEnterBackgroundNotification,
- object: nil)
- #endif
- }
-
- deinit {
- #if os(iOS) || os(tvOS)
- NotificationCenter.default.removeObserver(self)
- #endif
- }
-
- func value(forKey key: Key) -> Value? {
- lock.lock(); defer { lock.unlock() }
-
- guard let node = map[key] else {
- return nil
- }
-
- guard !node.value.isExpired else {
- _remove(node: node)
- return nil
- }
-
- // bubble node up to make it last added (most recently used)
- list.remove(node)
- list.append(node)
-
- return node.value.value
- }
-
- func set(_ value: Value, forKey key: Key, cost: Int = 0, ttl: TimeInterval? = nil) {
- lock.lock(); defer { lock.unlock() }
-
- let ttl = ttl ?? self.ttl
- let expiration = ttl == 0 ? nil : (Date() + ttl)
- let entry = Entry(value: value, key: key, cost: cost, expiration: expiration)
- _add(entry)
- _trim() // _trim is extremely fast, it's OK to call it each time
- }
-
- @discardableResult
- func removeValue(forKey key: Key) -> Value? {
- lock.lock(); defer { lock.unlock() }
-
- guard let node = map[key] else {
- return nil
- }
- _remove(node: node)
- return node.value.value
- }
-
- private func _add(_ element: Entry) {
- if let existingNode = map[element.key] {
- _remove(node: existingNode)
- }
- map[element.key] = list.append(element)
- totalCost += element.cost
- }
-
- private func _remove(node: LinkedList.Node) {
- list.remove(node)
- map[node.value.key] = nil
- totalCost -= node.value.cost
- }
-
- @objc
- dynamic func removeAll() {
- lock.sync {
- map.removeAll()
- list.removeAll()
- totalCost = 0
- }
- }
-
- private func _trim() {
- _trim(toCost: costLimit)
- _trim(toCount: countLimit)
- }
-
- @objc
- private dynamic func didEnterBackground() {
- // Remove most of the stored items when entering background.
- // This behavior is similar to `NSCache` (which removes all
- // items). This feature is not documented and may be subject
- // to change in future Nuke versions.
- lock.sync {
- _trim(toCost: Int(Double(costLimit) * 0.1))
- _trim(toCount: Int(Double(countLimit) * 0.1))
- }
- }
-
- func trim(toCost limit: Int) {
- lock.sync { _trim(toCost: limit) }
- }
-
- private func _trim(toCost limit: Int) {
- _trim(while: { totalCost > limit })
- }
-
- func trim(toCount limit: Int) {
- lock.sync { _trim(toCount: limit) }
- }
-
- private func _trim(toCount limit: Int) {
- _trim(while: { totalCount > limit })
- }
-
- private func _trim(while condition: () -> Bool) {
- while condition(), let node = list.first { // least recently used
- _remove(node: node)
- }
- }
-
- private struct Entry {
- let value: Value
- let key: Key
- let cost: Int
- let expiration: Date?
- var isExpired: Bool {
- guard let expiration = expiration else {
- return false
- }
- return expiration.timeIntervalSinceNow < 0
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImageDecoding.swift b/Pods/Nuke/Sources/ImageDecoding.swift
deleted file mode 100644
index 7be3d76..0000000
--- a/Pods/Nuke/Sources/ImageDecoding.swift
+++ /dev/null
@@ -1,244 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-#if !os(macOS)
-import UIKit
-#else
-import Cocoa
-#endif
-
-#if os(watchOS)
-import WatchKit
-#endif
-
-// MARK: - ImageDecoding
-
-/// Decodes image data.
-public protocol ImageDecoding {
- /// Produces an image from the image data. A decoder is a one-shot object
- /// created for a single image decoding session. If image pipeline has
- /// progressive decoding enabled, the `decode(data:isFinal:)` method gets
- /// called each time the data buffer has new data available. The decoder may
- /// decide whether or not to produce a new image based on the previous scans.
- func decode(data: Data, isFinal: Bool) -> PlatformImage?
-}
-
-extension ImageDecoding {
- public func decode(data: Data) -> PlatformImage? {
- return self.decode(data: data, isFinal: true)
- }
-}
-
-// An image decoder that uses native APIs. Supports progressive decoding.
-// The decoder is stateful.
-public final class ImageDecoder: ImageDecoding {
- // `nil` if decoder hasn't detected whether progressive decoding is enabled.
- private(set) var isProgressive: Bool?
- // Number of scans that the decoder has found so far. The last scan might be
- // incomplete at this point.
- private(set) var numberOfScans = 0
- private var lastStartOfScan: Int = 0 // Index of the last found Start of Scan
- private var scannedIndex: Int = -1 // Index at which previous scan was finished
-
- public init() { }
-
- public func decode(data: Data, isFinal: Bool) -> PlatformImage? {
- let format = ImageFormat.format(for: data)
-
- guard !isFinal else { // Just decode the data.
- let image = ImageDecoder.decode(data)
- // Keep original data around in case of GIF
- if ImagePipeline.Configuration.isAnimatedImageDataEnabled, case .gif? = format {
- image?.animatedImageData = data
- }
- return image
- }
-
- // Determined (if haven't determined yet) whether the image supports progressive
- // decoding or not (only proressive JPEG is allowed for now, but you can
- // add support for other formats by implementing your own decoder).
- isProgressive = isProgressive ?? format?.isProgressive
- guard isProgressive == true else {
- return nil
- }
-
- // Check if there is more data to scan.
- guard (scannedIndex + 1) < data.count else {
- return nil
- }
-
- // Start scaning from the where it left off previous time.
- var index = (scannedIndex + 1)
- var numberOfScans = self.numberOfScans
- while index < (data.count - 1) {
- scannedIndex = index
- // 0xFF, 0xDA - Start Of Scan
- if data[index] == 0xFF, data[index + 1] == 0xDA {
- lastStartOfScan = index
- numberOfScans += 1
- }
- index += 1
- }
-
- // Found more scans this the previous time
- guard numberOfScans > self.numberOfScans else {
- return nil
- }
- self.numberOfScans = numberOfScans
-
- // `> 1` checks that we've received a first scan (SOS) and then received
- // and also received a second scan (SOS). This way we know that we have
- // at least one full scan available.
- return (numberOfScans > 1 && lastStartOfScan > 0) ? ImageDecoder.decode(data[0.. PlatformImage? {
- #if os(macOS)
- return NSImage(data: data)
- #else
- return UIImage(data: data, scale: Screen.scale)
- #endif
- }
-}
-
-extension ImageDecoding {
- func decode(_ data: Data, urlResponse: URLResponse?, isFinal: Bool) -> ImageResponse? {
- func decode() -> PlatformImage? {
- return self.decode(data: data, isFinal: isFinal)
- }
- guard let image = autoreleasepool(invoking: decode) else {
- return nil
- }
- #if !os(macOS)
- ImageDecompression.setDecompressionNeeded(true, for: image)
- #endif
-
- let scanNumber: Int? = (self as? ImageDecoder)?.numberOfScans
- return ImageResponse(image: image, urlResponse: urlResponse, scanNumber: scanNumber)
- }
-}
-
-// MARK: - ImageDecoderRegistry
-
-/// A register of image codecs (only decoding).
-public final class ImageDecoderRegistry {
- /// A shared registry.
- public static let shared = ImageDecoderRegistry()
-
- private var matches = [(ImageDecodingContext) -> ImageDecoding?]()
-
- /// Returns a decoder which matches the given context.
- public func decoder(for context: ImageDecodingContext) -> ImageDecoding {
- for match in matches {
- if let decoder = match(context) {
- return decoder
- }
- }
- return ImageDecoder() // Return default decoder if couldn't find a custom one.
- }
-
- /// Registers a decoder to be used in a given decoding context. The closure
- /// is going to be executed before all other already registered closures.
- public func register(_ match: @escaping (ImageDecodingContext) -> ImageDecoding?) {
- matches.insert(match, at: 0)
- }
-
- func clear() {
- matches = []
- }
-}
-
-/// Image decoding context used when selecting which decoder to use.
-public struct ImageDecodingContext {
- public let request: ImageRequest
- public let data: Data
- public let urlResponse: URLResponse?
-
- public init(request: ImageRequest, data: Data, urlResponse: URLResponse?) {
- self.request = request
- self.data = data
- self.urlResponse = urlResponse
- }
-}
-
-// MARK: - Image Formats
-
-enum ImageFormat: Equatable {
- /// `isProgressive` is nil if we determined that it's a jpeg, but we don't
- /// know if it is progressive or baseline yet.
- case jpeg(isProgressive: Bool?)
- case png
- case gif
-
- // Returns `nil` if not enough data.
- static func format(for data: Data) -> ImageFormat? {
- // JPEG magic numbers https://en.wikipedia.org/wiki/JPEG
- if _match(data, [0xFF, 0xD8, 0xFF]) {
- var index = 3 // start scanning right after magic numbers
- while index < (data.count - 1) {
- // A example of first few bytes of progressive jpeg image:
- // FF D8 FF E0 00 10 4A 46 49 46 00 01 01 00 00 48 00 ...
- //
- // 0xFF, 0xC0 - Start Of Frame (baseline DCT)
- // 0xFF, 0xC2 - Start Of Frame (progressive DCT)
- // https://en.wikipedia.org/wiki/JPEG
- if data[index] == 0xFF {
- if data[index + 1] == 0xC2 {
- return .jpeg(isProgressive: true) // progressive
- }
- if data[index + 1] == 0xC0 {
- return .jpeg(isProgressive: false) // baseline
- }
- }
- index += 1
- }
- // It's a jpeg but we don't know if progressive or not yet.
- return .jpeg(isProgressive: nil)
- }
-
- // GIF magic numbers https://en.wikipedia.org/wiki/GIF
- if _match(data, [0x47, 0x49, 0x46]) {
- return .gif
- }
-
- // PNG Magic numbers https://en.wikipedia.org/wiki/Portable_Network_Graphics
- if _match(data, [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]) {
- return .png
- }
-
- // Either not enough data, or we just don't know this format yet.
- return nil
- }
-
- var isProgressive: Bool? {
- if case let .jpeg(isProgressive) = self {
- return isProgressive
- }
- return false
- }
-
- private static func _match(_ data: Data, _ numbers: [UInt8]) -> Bool {
- guard data.count >= numbers.count else {
- return false
- }
- return !zip(numbers.indices, numbers).contains { (index, number) in
- data[index] != number
- }
- }
-}
-
-// MARK: - Animated Images
-
-private var _animatedImageDataAK = "Nuke.AnimatedImageData.AssociatedKey"
-
-extension PlatformImage {
- // Animated image data. Only not `nil` when image data actually contains
- // an animated image.
- public var animatedImageData: Data? {
- get { return objc_getAssociatedObject(self, &_animatedImageDataAK) as? Data }
- set { objc_setAssociatedObject(self, &_animatedImageDataAK, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
- }
-}
diff --git a/Pods/Nuke/Sources/ImageEncoding.swift b/Pods/Nuke/Sources/ImageEncoding.swift
deleted file mode 100644
index 7da6839..0000000
--- a/Pods/Nuke/Sources/ImageEncoding.swift
+++ /dev/null
@@ -1,77 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-#if !os(macOS)
-import UIKit
-#else
-import Cocoa
-#endif
-
-#if os(watchOS)
-import WatchKit
-#endif
-
-// MARK: - ImageEncoding
-
-public protocol ImageEncoding {
- func encode(image: PlatformImage) -> Data?
-}
-
-// MARK: - ImageEncoder
-
-public struct ImageEncoder: ImageEncoding {
- private let compressionQuality: CGFloat
-
- init(compressionQuality: CGFloat = 0.8) {
- self.compressionQuality = compressionQuality
- }
-
- public func encode(image: PlatformImage) -> Data? {
- guard let cgImage = image.cgImage else {
- return nil
- }
- if cgImage.isOpaque {
- return ImageEncoder.jpegData(from: image, compressionQuality: compressionQuality)
- } else {
- return ImageEncoder.pngData(from: image)
- }
- }
-}
-
-/// Image encoding context used when selecting which encoder to use.
-public struct ImageEncodingContext {
- public let request: ImageRequest
- public let image: PlatformImage
- public let urlResponse: URLResponse?
-}
-
-#if !os(macOS)
-extension ImageEncoder {
- static func pngData(from image: UIImage) -> Data? {
- return image.pngData()
- }
-
- static func jpegData(from image: UIImage, compressionQuality: CGFloat) -> Data? {
- return image.jpegData(compressionQuality: compressionQuality)
- }
-}
-#else
-extension ImageEncoder {
- static func pngData(from image: NSImage) -> Data? {
- guard let cgImage = image.cgImage else {
- return nil
- }
- let rep = NSBitmapImageRep(cgImage: cgImage)
- return rep.representation(using: .png, properties: [:])
- }
-
- static func jpegData(from image: NSImage, compressionQuality: CGFloat) -> Data? {
- guard let cgImage = image.cgImage else {
- return nil
- }
- let rep = NSBitmapImageRep(cgImage: cgImage)
- return rep.representation(using: .jpeg, properties: [.compressionFactor: compressionQuality])
- }
-}
-#endif
diff --git a/Pods/Nuke/Sources/ImagePipeline.swift b/Pods/Nuke/Sources/ImagePipeline.swift
deleted file mode 100644
index 250d52c..0000000
--- a/Pods/Nuke/Sources/ImagePipeline.swift
+++ /dev/null
@@ -1,844 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-import os
-
-/// `ImagePipeline` loads and decodes image data, processes loaded images and
-/// stores them in caches.
-///
-/// See [Nuke's README](https://github.com/kean/Nuke) for a detailed overview of
-/// the image pipeline and all of the related classes.
-///
-/// If you want to build a system that fits your specific needs, see `ImagePipeline.Configuration`
-/// for a list of the available options. You can set custom data loaders and caches, configure
-/// image encoders and decoders, change the number of concurrent operations for each
-/// individual stage, disable and enable features like deduplication and rate limiting, and more.
-///
-/// `ImagePipeline` is fully thread-safe.
-public /* final */ class ImagePipeline {
- public let configuration: Configuration
- public var observer: ImagePipelineObserving?
-
- // The queue on which the entire subsystem is synchronized.
- private let queue = DispatchQueue(label: "com.github.kean.Nuke.ImagePipeline", target: .global(qos: .userInitiated))
-
- private var tasks = [ImageTask: TaskSubscription]()
-
- private let decompressedImageFetchTasks: TaskPool
- private let processedImageFetchTasks: TaskPool
- private let originalImageFetchTasks: TaskPool
- private let originalImageDataFetchTasks: TaskPool<(Data, URLResponse?), Error>
-
- private var nextTaskId = Atomic(0)
-
- private let rateLimiter: RateLimiter
-
- private let log: OSLog
-
- /// Shared image pipeline.
- public static var shared = ImagePipeline()
-
- /// Initializes `ImagePipeline` instance with the given configuration.
- ///
- /// - parameter configuration: `Configuration()` by default.
- public init(configuration: Configuration = Configuration()) {
- self.configuration = configuration
- self.rateLimiter = RateLimiter(queue: queue)
-
- let isDeduplicationEnabled = configuration.isDeduplicationEnabled
- self.decompressedImageFetchTasks = TaskPool(isDeduplicationEnabled)
- self.processedImageFetchTasks = TaskPool(isDeduplicationEnabled)
- self.originalImageFetchTasks = TaskPool(isDeduplicationEnabled)
- self.originalImageDataFetchTasks = TaskPool(isDeduplicationEnabled)
-
- if Configuration.isSignpostLoggingEnabled {
- self.log = OSLog(subsystem: "com.github.kean.Nuke.ImagePipeline", category: "Image Loading")
- } else {
- self.log = .disabled
- }
- }
-
- public convenience init(_ configure: (inout ImagePipeline.Configuration) -> Void) {
- var configuration = ImagePipeline.Configuration()
- configure(&configuration)
- self.init(configuration: configuration)
- }
-
- // MARK: - Loading Images
-
- /// Loads an image with the given url.
- ///
- /// The pipeline first checks if the image or image data exists in any of its caches.
- /// It checks if the processed image exists in the memory cache, then if the processed
- /// image data exists in the custom data cache (disabled by default), then if the data
- /// cache contains the original image data. Only if there is no cached data, the pipeline
- /// will start loading the data. When the data is loaded the pipeline decodes it, applies
- /// the processors, and decompresses the image in the background.
- ///
- /// To learn more about the pipeine, see the [README](https://github.com/kean/Nuke).
- ///
- /// # Deduplication
- ///
- /// The pipeline avoids doing any duplicated work when loading images. For example,
- /// let's take these two requests:
- ///
- /// ```swift
- /// let url = URL(string: "http://example.com/image")
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44)),
- /// ImageProcessor.GaussianBlur(radius: 8)
- /// ]))
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44))
- /// ]))
- /// ```
- ///
- /// Nuke will load the data only once, resize the image once and blur it also only once.
- /// There is no duplicated work done. The work only gets canceled when all the registered
- /// requests are, and the priority is based on the highest priority of the registered requests.
- ///
- /// # Configuration
- ///
- /// See `ImagePipeline.Configuration` to learn more about the pipeline features and
- /// how to enable/disable them.
- ///
- /// - parameter queue: A queue on which to execute `progress` and `completion`
- /// callbacks. By default, the pipeline uses `.main` queue.
- /// - parameter progress: A closure to be called periodically on the main thread
- /// when the progress is updated. `nil` by default.
- /// - parameter completion: A closure to be called on the main thread when the
- /// request is finished. `nil` by default.
- @discardableResult
- public func loadImage(with url: URL,
- queue: DispatchQueue? = nil,
- progress: ImageTask.ProgressHandler? = nil,
- completion: ImageTask.Completion? = nil) -> ImageTask {
- return loadImage(with: ImageRequest(url: url), queue: queue, progress: progress, completion: completion)
- }
-
- /// Loads an image for the given request using image loading pipeline.
- ///
- /// The pipeline first checks if the image or image data exists in any of its caches.
- /// It checks if the processed image exists in the memory cache, then if the processed
- /// image data exists in the custom data cache (disabled by default), then if the data
- /// cache contains the original image data. Only if there is no cached data, the pipeline
- /// will start loading the data. When the data is loaded the pipeline decodes it, applies
- /// the processors, and decompresses the image in the background.
- ///
- /// To learn more about the pipeine, see the [README](https://github.com/kean/Nuke).
- ///
- /// # Deduplication
- ///
- /// The pipeline avoids doing any duplicated work when loading images. For example,
- /// let's take these two requests:
- ///
- /// ```swift
- /// let url = URL(string: "http://example.com/image")
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44)),
- /// ImageProcessor.GaussianBlur(radius: 8)
- /// ]))
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44))
- /// ]))
- /// ```
- ///
- /// Nuke will load the data only once, resize the image once and blur it also only once.
- /// There is no duplicated work done. The work only gets canceled when all the registered
- /// requests are, and the priority is based on the highest priority of the registered requests.
- ///
- /// # Configuration
- ///
- /// See `ImagePipeline.Configuration` to learn more about the pipeline features and
- /// how to enable/disable them.
- ///
- /// - parameter queue: A queue on which to execute `progress` and `completion`
- /// callbacks. By default, the pipeline uses `.main` queue.
- /// - parameter progress: A closure to be called periodically on the main thread
- /// when the progress is updated. `nil` by default.
- /// - parameter completion: A closure to be called on the main thread when the
- /// request is finished. `nil` by default.
- @discardableResult
- public func loadImage(with request: ImageRequest,
- queue: DispatchQueue? = nil,
- progress progressHandler: ImageTask.ProgressHandler? = nil,
- completion: ImageTask.Completion? = nil) -> ImageTask {
- return loadImage(with: request, isMainThreadConfined: false, queue: queue) { task, event in
- switch event {
- case let .value(response, isCompleted):
- if isCompleted {
- completion?(.success(response))
- } else {
- progressHandler?(response, task.completedUnitCount, task.totalUnitCount)
- }
- case let .progress(progress):
- progressHandler?(nil, progress.completed, progress.total)
- case let .error(error):
- completion?(.failure(error))
- }
- }
- }
-
- /// - parameter isMainThreadConfined: Enables some performance optimizations like
- /// lock-free `ImageTask`.
- func loadImage(with request: ImageRequest,
- isMainThreadConfined: Bool,
- queue: DispatchQueue?,
- observer: @escaping (ImageTask, Task.Event) -> Void) -> ImageTask {
- let request = inheritOptions(request)
- let task = ImageTask(taskId: nextTaskId.increment(), request: request, isMainThreadConfined: isMainThreadConfined, isDataTask: false, queue: queue)
- task.pipeline = self
- self.queue.async {
- self.startImageTask(task, observer: observer)
- }
- return task
- }
-
- // MARK: - Loading Image Data
-
- /// Loads the image data for the given request. The data doesn't get decoded or processed in any
- /// other way.
- ///
- /// You can call `loadImage(:)` for the request at any point after calling `loadData(:)`, the
- /// pipeline will use the same operation to load the data, no duplicated work will be performed.
- ///
- /// - parameter queue: A queue on which to execute `progress` and `completion`
- /// callbacks. By default, the pipeline uses `.main` queue.
- /// - parameter progress: A closure to be called periodically on the main thread
- /// when the progress is updated. `nil` by default.
- /// - parameter completion: A closure to be called on the main thread when the
- /// request is finished.
- @discardableResult
- public func loadData(with request: ImageRequest,
- queue: DispatchQueue? = nil,
- progress: ((_ completed: Int64, _ total: Int64) -> Void)? = nil,
- completion: @escaping (Result<(data: Data, response: URLResponse?), ImagePipeline.Error>) -> Void) -> ImageTask {
- let task = ImageTask(taskId: nextTaskId.increment(), request: request, isDataTask: true, queue: queue)
- task.pipeline = self
- self.queue.async {
- self.startDataTask(task, progress: progress, completion: completion)
- }
- return task
- }
-
- // MARK: - Image Task Events
-
- func imageTaskCancelCalled(_ task: ImageTask) {
- queue.async {
- guard let subscription = self.tasks.removeValue(forKey: task) else { return }
- if !task.isDataTask {
- self.send(.cancelled, task)
- }
- subscription.unsubscribe()
- }
- }
-
- func imageTaskUpdatePriorityCalled(_ task: ImageTask, priority: ImageRequest.Priority) {
- queue.async {
- task._priority = priority
- guard let subscription = self.tasks[task] else { return }
- if !task.isDataTask {
- self.send(.priorityUpdated(priority: priority), task)
- }
- subscription.setPriority(priority)
- }
- }
-
- // MARK: - Cache
-
- /// Returns a cached response from the memory cache. Returns `nil` if the request disables
- /// memory cache reads.
- public func cachedResponse(for request: ImageRequest) -> ImageResponse? {
- guard request.options.memoryCacheOptions.isReadAllowed else { return nil }
-
- let request = inheritOptions(request)
- return configuration.imageCache?.cachedResponse(for: request)
- }
-
- private func storeResponse(_ response: ImageResponse, for request: ImageRequest, isCompleted: Bool) {
- guard isCompleted, request.options.memoryCacheOptions.isWriteAllowed else { return }
- configuration.imageCache?.storeResponse(response, for: request)
- }
-}
-
-// MARK: - Starting Image Tasks (Private)
-
-private extension ImagePipeline {
- func startImageTask(_ task: ImageTask, observer: @escaping (ImageTask, Task.Event) -> Void) {
- self.send(.started, task)
-
- tasks[task] = getDecompressedImage(for: task.request)
- .subscribe(priority: task._priority) { [weak self, weak task] event in
- guard let self = self, let task = task else { return }
-
- self.send(ImageTaskEvent(event), task)
-
- if event.isCompleted {
- self.tasks[task] = nil
- }
-
- (task.queue ?? self.configuration.callbackQueue).async {
- guard !task.isCancelled else { return }
- if case let .progress(progress) = event {
- task.setProgress(progress)
- }
- observer(task, event)
- }
- }
- }
-
- func startDataTask(_ task: ImageTask,
- progress progressHandler: ((_ completed: Int64, _ total: Int64) -> Void)?,
- completion: @escaping (Result<(data: Data, response: URLResponse?), ImagePipeline.Error>) -> Void) {
- tasks[task] = getOriginalImageData(for: task.request)
- .subscribe(priority: task._priority) { [weak self, weak task] event in
- guard let self = self, let task = task else { return }
-
- if event.isCompleted {
- self.tasks[task] = nil
- }
-
- (task.queue ?? self.configuration.callbackQueue).async {
- guard !task.isCancelled else { return }
-
- switch event {
- case let .value(response, isCompleted):
- if isCompleted {
- completion(.success(response))
- }
- case let .progress(progress):
- task.setProgress(progress)
- progressHandler?(progress.completed, progress.total)
- case let .error(error):
- completion(.failure(error))
- }
- }
- }
- }
-}
-
-// MARK: - Get Decompressed Image (Private)
-
-private extension ImagePipeline {
- typealias DecompressedImageTask = Task
-
- func getDecompressedImage(for request: ImageRequest) -> DecompressedImageTask.Publisher {
- let key = request.makeLoadKeyForProcessedImage()
- return decompressedImageFetchTasks.publisher(withKey: key, starter: { task in
- self.loadDecompressedImage(for: request, task: task)
- })
- }
-
- func loadDecompressedImage(for request: ImageRequest, task: DecompressedImageTask) {
- if let response = cachedResponse(for: request) {
- return task.send(value: response, isCompleted: true)
- }
-
- task.dependency = getProcessedImage(for: request).subscribe(task) { [weak self] image, isCompleted, task in
- self?.decompressProcessedImage(image, isCompleted: isCompleted, for: request, task: task)
- }
- }
-
- #if os(macOS)
- func decompressProcessedImage(_ response: ImageResponse, isCompleted: Bool, for request: ImageRequest, task: DecompressedImageTask) {
- storeResponse(response, for: request, isCompleted: isCompleted)
- task.send(value: response, isCompleted: isCompleted) // There is no decompression on macOS
- }
- #else
- func decompressProcessedImage(_ response: ImageResponse, isCompleted: Bool, for request: ImageRequest, task: DecompressedImageTask) {
- guard isDecompressionNeeded(for: response) else {
- storeResponse(response, for: request, isCompleted: isCompleted)
- task.send(value: response, isCompleted: isCompleted)
- return
- }
-
- if isCompleted {
- task.operation?.cancel() // Cancel any potential pending progressive decompression tasks
- } else if task.operation != nil {
- return // Back-pressure: we are receiving data too fast
- }
-
- guard !task.isDisposed else { return }
-
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Decompress Image")
- log.signpost(.begin, isCompleted ? "Final image" : "Progressive image")
- let response = response.map(ImageDecompression().decompress(image:)) ?? response
- log.signpost(.end)
-
- self.queue.async {
- self.storeResponse(response, for: request, isCompleted: isCompleted)
- task.send(value: response, isCompleted: isCompleted)
- }
- }
- task.operation = operation
- configuration.imageDecompressingQueue.addOperation(operation)
- }
-
- func isDecompressionNeeded(for response: ImageResponse) -> Bool {
- return configuration.isDecompressionEnabled &&
- ImageDecompression.isDecompressionNeeded(for: response.image) ?? false &&
- !(Configuration.isAnimatedImageDataEnabled && response.image.animatedImageData != nil)
- }
- #endif
-}
-
-// MARK: - Get Processed Image (Private)
-
-private extension ImagePipeline {
- typealias ProcessedImageTask = Task
-
- func getProcessedImage(for request: ImageRequest) -> ProcessedImageTask.Publisher {
- guard !request.processors.isEmpty else {
- return getOriginalImage(for: request) // No processing needed
- }
-
- let key = request.makeLoadKeyForProcessedImage()
- return processedImageFetchTasks.publisher(withKey: key, starter: { task in
- self.loadProcessedImage(for: request, task: task)
- })
- }
-
- func loadProcessedImage(for request: ImageRequest, task: ProcessedImageTask) {
- if let response = cachedResponse(for: request) {
- return task.send(value: response, isCompleted: true)
- }
-
- guard !request.processors.isEmpty, let dataCache = configuration.dataCache, configuration.isDataCachingForProcessedImagesEnabled else {
- return loadOriginaImage(for: request, task: task)
- }
-
- let key = request.makeCacheKeyForProcessedImageData()
-
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Read Cached Processed Image Data")
- log.signpost(.begin)
- let data = dataCache.cachedData(for: key)
- log.signpost(.end)
-
- self.queue.async {
- if let data = data {
- self.decodeProcessedImageData(data, for: request, task: task)
- } else {
- self.loadOriginaImage(for: request, task: task)
- }
- }
- }
- task.operation = operation
- configuration.dataCachingQueue.addOperation(operation)
- }
-
- func decodeProcessedImageData(_ data: Data, for request: ImageRequest, task: ProcessedImageTask) {
- guard !task.isDisposed else { return }
-
- let decoderContext = ImageDecodingContext(request: request, data: data, urlResponse: nil)
- let decoder = configuration.makeImageDecoder(decoderContext)
-
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Decode Cached Processed Image Data")
- log.signpost(.begin)
- let response = decoder.decode(data, urlResponse: nil, isFinal: true)
- log.signpost(.end)
-
- self.queue.async {
- if let response = response {
- task.send(value: response, isCompleted: true)
- } else {
- self.loadOriginaImage(for: request, task: task)
- }
- }
- }
- task.operation = operation
- configuration.imageDecodingQueue.addOperation(operation)
- }
-
- func loadOriginaImage(for request: ImageRequest, task: ProcessedImageTask) {
- assert(!request.processors.isEmpty)
- guard !task.isDisposed, !request.processors.isEmpty else { return }
-
- let processor: ImageProcessing
- var subRequest = request
- if configuration.isDeduplicationEnabled {
- // Recursively call getProcessedImage until there are no more processors left.
- // Each time getProcessedImage is called it tries to find an existing
- // task ("deduplication") to avoid doing any duplicated work.
- processor = request.processors.last!
- subRequest.processors = Array(request.processors.dropLast())
- } else {
- // Perform all transformations in one go
- processor = ImageProcessor.Composition(request.processors)
- subRequest.processors = []
- }
- task.dependency = getProcessedImage(for: subRequest).subscribe(task) { [weak self] image, isCompleted, task in
- self?.processImage(image, isCompleted: isCompleted, for: request, processor: processor, task: task)
- }
- }
-
- func processImage(_ response: ImageResponse, isCompleted: Bool, for request: ImageRequest, processor: ImageProcessing, task: ProcessedImageTask) {
- guard !(Configuration.isAnimatedImageDataEnabled && response.image.animatedImageData != nil) else {
- task.send(value: response, isCompleted: isCompleted)
- return
- }
-
- if isCompleted {
- task.operation?.cancel() // Cancel any potential pending progressive processing tasks
- } else if task.operation != nil {
- return // Back pressure - already processing another progressive image
- }
-
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Process Image")
- log.signpost(.begin, "\(processor), \(isCompleted ? "final" : "progressive") image")
- let context = ImageProcessingContext(request: request, isFinal: isCompleted, scanNumber: response.scanNumber)
- let response = response.map { processor.process(image: $0, context: context) }
- log.signpost(.end)
-
- self.queue.async {
- guard let response = response else {
- if isCompleted {
- task.send(error: .processingFailed)
- } // Ignore when progressive processing fails
- return
- }
- if isCompleted {
- self.storeProcessedImageInDataCache(response, request: request)
- }
- task.send(value: response, isCompleted: isCompleted)
- }
- }
- task.operation = operation
- configuration.imageProcessingQueue.addOperation(operation)
- }
-
- func storeProcessedImageInDataCache(_ response: ImageResponse, request: ImageRequest) {
- guard let dataCache = configuration.dataCache, configuration.isDataCachingForProcessedImagesEnabled else {
- return
- }
- let context = ImageEncodingContext(request: request, image: response.image, urlResponse: response.urlResponse)
- let encoder = configuration.makeImageEncoder(context)
- configuration.imageEncodingQueue.addOperation {
- let log = Log(self.log, "Encode Image")
- log.signpost(.begin)
- let encodedData = encoder.encode(image: response.image)
- log.signpost(.end)
-
- guard let data = encodedData else { return }
- let key = request.makeCacheKeyForProcessedImageData()
- dataCache.storeData(data, for: key) // This is instant
- }
- }
-}
-
-// MARK: - Get Original Image (Private)
-
-private extension ImagePipeline {
- typealias OriginalImageTask = Task
-
- final class OriginalImageTaskContext {
- let request: ImageRequest
- var decoder: ImageDecoding?
-
- init(request: ImageRequest) {
- self.request = request
- }
- }
-
- func getOriginalImage(for request: ImageRequest) -> OriginalImageTask.Publisher {
- let key = request.makeLoadKeyForOriginalImage()
- return originalImageFetchTasks.publisher(withKey: key, starter: { task in
- let context = OriginalImageTaskContext(request: request)
- task.dependency = self.getOriginalImageData(for: request)
- .subscribe(task) { [weak self] value, isCompleted, task in
- self?.decodeData(value.0, urlResponse: value.1, isCompleted: isCompleted, task: task, context: context)
- }
- })
- }
-
- func decodeData(_ data: Data, urlResponse: URLResponse?, isCompleted: Bool, task: OriginalImageTask, context: OriginalImageTaskContext) {
- if isCompleted {
- task.operation?.cancel() // Cancel any potential pending progressive decoding tasks
- } else if !configuration.isProgressiveDecodingEnabled || task.operation != nil {
- return // Back pressure - already decoding another progressive data chunk
- }
-
- // Sanity check
- guard !data.isEmpty else {
- if isCompleted {
- task.send(error: .decodingFailed)
- }
- return
- }
-
- let decoder = self.decoder(for: context, data: data, urlResponse: urlResponse)
-
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Decode Image Data")
- log.signpost(.begin, "\(isCompleted ? "Final" : "Progressive") image")
- let response = decoder.decode(data, urlResponse: urlResponse, isFinal: isCompleted)
- log.signpost(.end)
-
- self.queue.async {
- if let response = response {
- task.send(value: response, isCompleted: isCompleted)
- } else if isCompleted {
- task.send(error: .decodingFailed)
- }
- }
- }
- task.operation = operation
- configuration.imageDecodingQueue.addOperation(operation)
- }
-
- // Lazily creates decoding for task
- func decoder(for context: OriginalImageTaskContext, data: Data, urlResponse: URLResponse?) -> ImageDecoding {
- // Return the existing processor in case it has already been created.
- if let decoder = context.decoder {
- return decoder
- }
- let decoderContext = ImageDecodingContext(request: context.request, data: data, urlResponse: urlResponse)
- let decoder = configuration.makeImageDecoder(decoderContext)
- context.decoder = decoder
- return decoder
- }
-}
-
-// MARK: - Get Original Image Data (Private)
-
-private extension ImagePipeline {
- typealias OriginalImageDataTask = Task<(Data, URLResponse?), Error>
-
- final class OriginalImageDataTaskContext {
- let request: ImageRequest
- var urlResponse: URLResponse?
- var resumableData: ResumableData?
- var resumedDataCount: Int64 = 0
- lazy var data = Data()
-
- init(request: ImageRequest) {
- self.request = request
- }
- }
-
- func getOriginalImageData(for request: ImageRequest) -> OriginalImageDataTask.Publisher {
- let key = request.makeLoadKeyForOriginalImage()
- return originalImageDataFetchTasks.publisher(withKey: key, starter: { task in
- let context = OriginalImageDataTaskContext(request: request)
- if self.configuration.isRateLimiterEnabled {
- // Rate limiter is synchronized on pipeline's queue. Delayed work is
- // executed asynchronously also on this same queue.
- self.rateLimiter.execute { [weak self, weak task] in
- guard let self = self, let task = task, !task.isDisposed else {
- return false
- }
- self.loadImageDataFromCache(for: task, context: context)
- return true
- }
- } else { // Start loading immediately.
- self.loadImageDataFromCache(for: task, context: context)
- }
- })
- }
-
- func loadImageDataFromCache(for task: OriginalImageDataTask, context: OriginalImageDataTaskContext) {
- guard let cache = configuration.dataCache, configuration.isDataCachingForOriginalImageDataEnabled else {
- loadImageData(for: task, context: context) // Skip disk cache lookup, load data
- return
- }
-
- let key = context.request.makeCacheKeyForOriginalImageData()
- let operation = BlockOperation { [weak self, weak task] in
- guard let self = self, let task = task else { return }
-
- let log = Log(self.log, "Read Cached Image Data")
- log.signpost(.begin)
- let data = cache.cachedData(for: key)
- log.signpost(.end)
-
- self.queue.async {
- if let data = data {
- task.send(value: (data, nil), isCompleted: true)
- } else {
- self.loadImageData(for: task, context: context)
- }
- }
- }
- task.operation = operation
- configuration.dataCachingQueue.addOperation(operation)
- }
-
- func loadImageData(for task: OriginalImageDataTask, context: OriginalImageDataTaskContext) {
- // Wrap data request in an operation to limit maximum number of
- // concurrent data tasks.
- let operation = Operation(starter: { [weak self, weak task] finish in
- guard let self = self, let task = task else {
- return finish()
- }
- self.queue.async {
- self.loadImageData(for: task, context: context, finish: finish)
- }
- })
- configuration.dataLoadingQueue.addOperation(operation)
- task.operation = operation
- }
-
- // This methods gets called inside data loading operation (Operation).
- func loadImageData(for task: OriginalImageDataTask, context: OriginalImageDataTaskContext, finish: @escaping () -> Void) {
- guard !task.isDisposed else {
- return finish() // Task was cancelled by the time it got a chance to start
- }
-
- var urlRequest = context.request.urlRequest
-
- // Read and remove resumable data from cache (we're going to insert it
- // back in the cache if the request fails to complete again).
- if configuration.isResumableDataEnabled,
- let resumableData = ResumableData.removeResumableData(for: urlRequest) {
- // Update headers to add "Range" and "If-Range" headers
- resumableData.resume(request: &urlRequest)
- // Save resumable data to be used later (before using it, the pipeline
- // verifies that the server returns "206 Partial Content")
- context.resumableData = resumableData
- }
-
- let log = Log(self.log, "Load Image Data")
- log.signpost(.begin, "URL: \(urlRequest.url?.absoluteString ?? ""), resumable data: \(Log.bytes(context.resumableData?.data.count ?? 0))")
-
- let dataTask = configuration.dataLoader.loadData(
- with: urlRequest,
- didReceiveData: { [weak self, weak task] data, response in
- guard let self = self, let task = task else { return }
- self.queue.async {
- self.imageDataLoadingTask(task, context: context, didReceiveData: data, response: response, log: log)
- }
- },
- completion: { [weak self, weak task] error in
- finish() // Finish the operation!
- guard let self = self, let task = task else { return }
- self.queue.async {
- log.signpost(.end, "Finished with size \(Log.bytes(context.data.count))")
- self.imageDataLoadingTask(task, context: context, didFinishLoadingDataWithError: error)
- }
- })
-
- task.onCancelled = { [weak self] in
- guard let self = self else { return }
-
- log.signpost(.end, "Cancelled")
- dataTask.cancel()
- finish() // Finish the operation!
-
- self.tryToSaveResumableData(for: context)
- }
- }
-
- func imageDataLoadingTask(_ task: OriginalImageDataTask, context: OriginalImageDataTaskContext, didReceiveData chunk: Data, response: URLResponse, log: Log) {
- // Check if this is the first response.
- if context.urlResponse == nil {
- // See if the server confirmed that the resumable data can be used
- if let resumableData = context.resumableData, ResumableData.isResumedResponse(response) {
- context.data = resumableData.data
- context.resumedDataCount = Int64(resumableData.data.count)
- log.signpost(.event, "Resumed with data \(Log.bytes(context.resumedDataCount))")
- }
- context.resumableData = nil // Get rid of resumable data
- }
-
- // Append data and save response
- context.data.append(chunk)
- context.urlResponse = response
-
- let progress = TaskProgress(completed: Int64(context.data.count), total: response.expectedContentLength + context.resumedDataCount)
- task.send(progress: progress)
-
- // If the image hasn't been fully loaded yet, give decoder a change
- // to decode the data chunk. In case `expectedContentLength` is `0`,
- // progressive decoding doesn't run.
- guard context.data.count < response.expectedContentLength else { return }
-
- task.send(value: (context.data, response))
- }
-
- func imageDataLoadingTask(_ task: OriginalImageDataTask, context: OriginalImageDataTaskContext, didFinishLoadingDataWithError error: Swift.Error?) {
- if let error = error {
- tryToSaveResumableData(for: context)
- task.send(error: .dataLoadingFailed(error))
- return
- }
-
- // Sanity check, should never happen in practice
- guard !context.data.isEmpty else {
- task.send(error: .dataLoadingFailed(URLError(.unknown, userInfo: [:])))
- return
- }
-
- // Store in data cache
- if let dataCache = configuration.dataCache, configuration.isDataCachingForOriginalImageDataEnabled {
- let key = context.request.makeCacheKeyForOriginalImageData()
- dataCache.storeData(context.data, for: key)
- }
-
- task.send(value: (context.data, context.urlResponse), isCompleted: true)
- }
-
- func tryToSaveResumableData(for context: OriginalImageDataTaskContext) {
- // Try to save resumable data in case the task was cancelled
- // (`URLError.cancelled`) or failed to complete with other error.
- if configuration.isResumableDataEnabled,
- let response = context.urlResponse, !context.data.isEmpty,
- let resumableData = ResumableData(response: response, data: context.data) {
- ResumableData.storeResumableData(resumableData, for: context.request.urlRequest)
- }
- }
-}
-
-// MARK: - Misc (Private)
-
-private extension ImagePipeline {
- /// Inherits some of the pipeline configuration options like processors.
- func inheritOptions(_ request: ImageRequest) -> ImageRequest {
- // Do not manipulate is the request has some processors already.
- guard request.processors.isEmpty, !configuration.processors.isEmpty else { return request }
-
- var request = request
- request.processors = configuration.processors
- return request
- }
-
- func send(_ event: ImageTaskEvent, _ task: ImageTask) {
- observer?.pipeline(self, imageTask: task, didReceiveEvent: event)
- }
-}
-
-// MARK: - Errors
-
-public extension ImagePipeline {
- /// Represents all possible image pipeline errors.
- enum Error: Swift.Error, CustomDebugStringConvertible {
- /// Data loader failed to load image data with a wrapped error.
- case dataLoadingFailed(Swift.Error)
- /// Decoder failed to produce a final image.
- case decodingFailed
- /// Processor failed to produce a final image.
- case processingFailed
-
- public var debugDescription: String {
- switch self {
- case let .dataLoadingFailed(error): return "Failed to load image data: \(error)"
- case .decodingFailed: return "Failed to create an image from the image data"
- case .processingFailed: return "Failed to process the image"
- }
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImagePipelineConfiguration.swift b/Pods/Nuke/Sources/ImagePipelineConfiguration.swift
deleted file mode 100644
index c65b4c5..0000000
--- a/Pods/Nuke/Sources/ImagePipelineConfiguration.swift
+++ /dev/null
@@ -1,211 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-// MARK: - ImagePipeline.Configuration
-
-extension ImagePipeline {
- public struct Configuration {
- // MARK: - Dependencies
-
- /// Image cache used by the pipeline.
- public var imageCache: ImageCaching?
-
- /// Data loader used by the pipeline.
- public var dataLoader: DataLoading
-
- /// Data cache used by the pipeline.
- public var dataCache: DataCaching?
-
- /// Default implementation uses shared `ImageDecoderRegistry` to create
- /// a decoder that matches the context.
- public var makeImageDecoder: (ImageDecodingContext) -> ImageDecoding = {
- return ImageDecoderRegistry.shared.decoder(for: $0)
- }
-
- /// Returns `ImageEncoder()` by default.
- public var makeImageEncoder: (ImageEncodingContext) -> ImageEncoding = { _ in
- return ImageEncoder()
- }
-
- // MARK: - Operation Queues
-
- /// Data loading queue. Default maximum concurrent task count is 6.
- public var dataLoadingQueue = OperationQueue()
-
- /// Data caching queue. Default maximum concurrent task count is 2.
- public var dataCachingQueue = OperationQueue()
-
- /// Image decoding queue. Default maximum concurrent task count is 1.
- public var imageDecodingQueue = OperationQueue()
-
- /// Image encodign queue. Default maximum concurrent task count is 1.
- public var imageEncodingQueue = OperationQueue()
-
- /// Image processing queue. Default maximum concurrent task count is 2.
- public var imageProcessingQueue = OperationQueue()
-
- #if !os(macOS)
- /// Image decompressing queue. Default maximum concurrent task count is 2.
- public var imageDecompressingQueue = OperationQueue()
- #endif
-
- // MARK: - Processors
-
- /// Processors to be applied by default to all images loaded by the
- /// pipeline.
- /// If a request has a non-empty processors list, the pipeline won't
- /// apply its own processors, leaving the request as is.
- /// This lets clients have an override point on request basis.
- public var processors: [ImageProcessing] = []
-
- // MARK: - Options
-
- /// A queue on which all callbacks, like `progress` and `completion`
- /// callbacks are called. `.main` by default.
- public var callbackQueue = DispatchQueue.main
-
- #if !os(macOS)
- /// Decompresses the loaded images. `true` by default.
- ///
- /// Decompressing compressed image formats (such as JPEG) can significantly
- /// improve drawing performance as it allows a bitmap representation to be
- /// created in a background rather than on the main thread.
- public var isDecompressionEnabled = true
- #endif
-
- /// `true` by default. If `true`, original image data provided by
- /// `dataLoader` will be stored in a custom `dataCache` provided in the
- /// configuration.
- ///
- /// If the value is set to `true`, you must also provide `dataCache`
- /// instance in the configuration.
- public var isDataCachingForOriginalImageDataEnabled = true
-
- /// `false` by default. If `true`, the images for which one or more
- /// processors were specified will be encoded and stored in data cache.
- ///
- /// If the value is set to `true`, you must also provide `dataCache`
- /// instance in the configuration.
- //
- /// - WARNING: When enabled every intermediate processed image will be
- /// stored in disk data cache if it is enabled. To avoid storing
- /// unwanted intermediate images, use `ImageProcessor.Composition` to
- /// compose multiple processors into a single one.
- public var isDataCachingForProcessedImagesEnabled = false
-
- /// `true` by default. If `true` the pipeline avoids duplicated work when
- /// loading images. The work only gets cancelled when all the registered
- /// requests are. The pipeline also automatically manages the priority of the
- /// deduplicated work.
- ///
- /// Let't take this two requests for example:
- ///
- /// ```swift
- /// let url = URL(string: "http://example.com/image")
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44)),
- /// ImageProcessor.GaussianBlur(radius: 8)
- /// ]))
- /// pipeline.loadImage(with: ImageRequest(url: url, processors: [
- /// ImageProcessor.Resize(size: CGSize(width: 44, height: 44))
- /// ]))
- /// ```
- ///
- /// Nuke will load the image data only once, resize the image once and
- /// apply the blur also only once. There is no duplicated work done at
- /// any stage.
- public var isDeduplicationEnabled = true
-
- /// `true` by default. It `true` the pipeline will rate limits the requests
- /// to prevent trashing of the underlying systems (e.g. `URLSession`).
- /// The rate limiter only comes into play when the requests are started
- /// and cancelled at a high rate (e.g. scrolling through a collection view).
- public var isRateLimiterEnabled = true
-
- /// `false` by default. If `true` the pipeline will try to produce a new
- /// image each time it receives a new portion of data from data loader.
- /// The decoder used by the image loading session determines whether
- /// to produce a partial image or not.
- public var isProgressiveDecodingEnabled = false
-
- /// If the data task is terminated (either because of a failure or a
- /// cancellation) and the image was partially loaded, the next load will
- /// resume where it was left off. Supports both validators (`ETag`,
- /// `Last-Modified`). The resumable downloads are enabled by default.
- public var isResumableDataEnabled = true
-
- // MARK: - Options (Shared)
-
- /// If `true` pipeline will detects GIFs and set `animatedImageData`
- /// (`UIImage` property). It will also disable processing of such images,
- /// and alter the way cache cost is calculated. However, this will not
- /// enable actual animated image rendering. To do that take a look at
- /// satellite projects (FLAnimatedImage and Gifu plugins for Nuke).
- /// `false` by default (to preserve resources).
- public static var isAnimatedImageDataEnabled = false
-
- /// `false` by default. If `true`, enables `os_signpost` logging for
- /// measuring performance. You can visually see all the performance
- /// metrics in `os_signpost` Instrument. For more information see
- /// https://developer.apple.com/documentation/os/logging and
- /// https://developer.apple.com/videos/play/wwdc2018/405/.
- public static var isSignpostLoggingEnabled = false
-
- // MARK: - Initializer
-
- /// Creates a default configuration.
- /// - parameter dataLoader: `DataLoader()` by default.
- /// - parameter imageCache: `Cache.shared` by default.
- public init(dataLoader: DataLoading = DataLoader(), imageCache: ImageCaching? = ImageCache.shared) {
- self.dataLoader = dataLoader
- self.imageCache = imageCache
-
- self.dataLoadingQueue.maxConcurrentOperationCount = 6
- self.dataCachingQueue.maxConcurrentOperationCount = 2
- self.imageDecodingQueue.maxConcurrentOperationCount = 1
- self.imageEncodingQueue.maxConcurrentOperationCount = 1
- self.imageProcessingQueue.maxConcurrentOperationCount = 2
- #if !os(macOS)
- self.imageDecompressingQueue.maxConcurrentOperationCount = 2
- #endif
- }
- }
-}
-
-// MARK: - ImagePipelineObserving
-
-public enum ImageTaskEvent {
- case started
- case cancelled
- case priorityUpdated(priority: ImageRequest.Priority)
- case intermediateResponseReceived(response: ImageResponse)
- case progressUpdated(completedUnitCount: Int64, totalUnitCount: Int64)
- case completed(result: Result)
-}
-
-/// Allows you to tap into internal events of the image pipeline. Events are
-/// delivered on the internal serial dispatch queue.
-public protocol ImagePipelineObserving {
- /// Delivers the events produced by the image tasks started via `loadImage` method.
- func pipeline(_ pipeline: ImagePipeline, imageTask: ImageTask, didReceiveEvent event: ImageTaskEvent)
-}
-
-extension ImageTaskEvent {
- init(_ event: Task.Event) {
- switch event {
- case let .error(error):
- self = .completed(result: .failure(error))
- case let .value(response, isCompleted):
- if isCompleted {
- self = .completed(result: .success(response))
- } else {
- self = .intermediateResponseReceived(response: response)
- }
- case let .progress(progress):
- self = .progressUpdated(completedUnitCount: progress.completed, totalUnitCount: progress.total)
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImagePreheater.swift b/Pods/Nuke/Sources/ImagePreheater.swift
deleted file mode 100644
index fd07ad3..0000000
--- a/Pods/Nuke/Sources/ImagePreheater.swift
+++ /dev/null
@@ -1,183 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-/// Prefetches and caches image in order to eliminate delays when you request
-/// individual images later.
-///
-/// To start preheating call `startPreheating(with:)` method. When you
-/// need an individual image just start loading an image using `Loading` object.
-/// When preheating is no longer necessary call `stopPreheating(with:)` method.
-///
-/// All `Preheater` methods are thread-safe.
-public final class ImagePreheater {
- private let pipeline: ImagePipeline
- private let queue = DispatchQueue(label: "com.github.kean.Nuke.Preheater", target: .global(qos: .userInitiated))
- private let preheatQueue = OperationQueue()
- private var tasks = [AnyHashable: Task]()
- private let destination: Destination
-
- /// Prefetching destination.
- public enum Destination {
- /// Prefetches the image and stores it both in memory and disk caches
- /// (in case they are enabled, naturally, there is no reason to prefetch
- /// unless they are).
- case memoryCache
-
- /// Prefetches image data and stores in disk cache. Will no decode
- /// the image data and will therefore use less CPU.
- case diskCache
- }
-
- /// Initializes the `Preheater` instance.
- /// - parameter manager: `Loader.shared` by default.
- /// - parameter `maxConcurrentRequestCount`: 2 by default.
- /// - parameter destination: `.memoryCache` by default.
- public init(pipeline: ImagePipeline = ImagePipeline.shared,
- destination: Destination = .memoryCache,
- maxConcurrentRequestCount: Int = 2) {
- self.pipeline = pipeline
- self.destination = destination
- self.preheatQueue.maxConcurrentOperationCount = maxConcurrentRequestCount
- }
-
- /// Starte preheating images for the given urls.
- /// - note: See `func startPreheating(with requests: [ImageRequest])` for more info
- public func startPreheating(with urls: [URL]) {
- startPreheating(with: _requests(for: urls))
- }
-
- /// Starts preheating images for the given requests.
- ///
- /// When you call this method, `Preheater` starts to load and cache images
- /// for the given requests. At any time afterward, you can create tasks
- /// for individual images with equivalent requests.
- public func startPreheating(with requests: [ImageRequest]) {
- queue.async {
- for request in requests {
- self._startPreheating(with: request)
- }
- }
- }
-
- private func _startPreheating(with request: ImageRequest) {
- let key = request.makeLoadKeyForProcessedImage()
-
- guard tasks[key] == nil else {
- return // Already started prefetching
- }
-
- guard pipeline.configuration.imageCache?.cachedResponse(for: request) == nil else {
- return // The image is already in memory cache
- }
-
- let task = Task(request: request, key: key)
-
- // Use `Operation` to limit maximum number of concurrent preheating jobs
- let operation = Operation(starter: { [weak self, weak task] finish in
- guard let self = self, let task = task else {
- return finish()
- }
- self.queue.async {
- self.loadImage(with: request, task: task, finish: finish)
- }
- })
- preheatQueue.addOperation(operation)
- tasks[key] = task
- }
-
- private func loadImage(with request: ImageRequest, task: Task, finish: @escaping () -> Void) {
- guard !task.isCancelled else {
- return finish()
- }
-
- let imageTask: ImageTask
- switch destination {
- case .diskCache:
- imageTask = pipeline.loadData(with: request) { [weak self] _ in
- self?._remove(task)
- finish()
- }
- case .memoryCache:
- imageTask = pipeline.loadImage(with: request) { [weak self] _ in
- self?._remove(task)
- finish()
- }
- }
- task.onCancelled = {
- imageTask.cancel()
- finish()
- }
- }
-
- private func _remove(_ task: Task) {
- queue.async {
- guard self.tasks[task.key] === task else {
- return
- }
- self.tasks[task.key] = nil
- }
- }
-
- /// Stops preheating images for the given urls.
- public func stopPreheating(with urls: [URL]) {
- stopPreheating(with: _requests(for: urls))
- }
-
- /// Stops preheating images for the given requests and cancels outstanding
- /// requests.
- ///
- /// - parameter destination: `.memoryCache` by default.
- public func stopPreheating(with requests: [ImageRequest]) {
- queue.async {
- for request in requests {
- self._stopPreheating(with: request)
- }
- }
- }
-
- private func _stopPreheating(with request: ImageRequest) {
- if let task = tasks[request.makeLoadKeyForProcessedImage()] {
- tasks[task.key] = nil
- task.cancel()
- }
- }
-
- /// Stops all preheating tasks.
- public func stopPreheating() {
- queue.async {
- self.tasks.values.forEach { $0.cancel() }
- self.tasks.removeAll()
- }
- }
-
- private func _requests(for urls: [URL]) -> [ImageRequest] {
- return urls.map {
- var request = ImageRequest(url: $0)
- request.priority = .low
- return request
- }
- }
-
- private final class Task {
- let key: AnyHashable
- let request: ImageRequest
- var isCancelled = false
- var onCancelled: (() -> Void)?
- weak var operation: Operation?
-
- init(request: ImageRequest, key: AnyHashable) {
- self.request = request
- self.key = key
- }
-
- func cancel() {
- guard !isCancelled else { return }
- isCancelled = true
- operation?.cancel()
- onCancelled?()
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImageProcessing.swift b/Pods/Nuke/Sources/ImageProcessing.swift
deleted file mode 100644
index 81fb502..0000000
--- a/Pods/Nuke/Sources/ImageProcessing.swift
+++ /dev/null
@@ -1,750 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-#if os(iOS) || os(tvOS) || os(watchOS)
-import UIKit
-#endif
-
-#if os(watchOS)
-import WatchKit
-#endif
-
-#if os(macOS)
-import Cocoa
-#endif
-
-// MARK: - ImageProcessing
-
-/// Performs image processing.
-public protocol ImageProcessing {
- /// Returns processed image.
- func process(image: PlatformImage, context: ImageProcessingContext?) -> PlatformImage?
-
- /// Returns a string which uniquely identifies the processor.
- ///
- /// Consider using the reverse DNS notation.
- var identifier: String { get }
-
- /// Returns a unique processor identifier.
- ///
- /// The default implementation simply returns `var identifier: String` but
- /// can be overridden as a performance optimization - creating and comparing
- /// strings is _expensive_ so you can opt-in to return something which is
- /// fast to create and to compare. See `ImageProcessor.Resize` to example.
- var hashableIdentifier: AnyHashable { get }
-}
-
-extension ImageProcessing {
- public func process(image: PlatformImage) -> PlatformImage? {
- return self.process(image: image, context: nil)
- }
-}
-
-public extension ImageProcessing {
- var hashableIdentifier: AnyHashable {
- return identifier
- }
-}
-
-/// Image processing context used when selecting which processor to use.
-public struct ImageProcessingContext {
- public let request: ImageRequest
- public let isFinal: Bool
- public let scanNumber: Int? // need a more general purpose way to implement this
-
- public init(request: ImageRequest, isFinal: Bool, scanNumber: Int?) {
- self.request = request
- self.isFinal = isFinal
- self.scanNumber = scanNumber
- }
-}
-
-// MARK: - ImageProcessor
-
-/// A namespace for types related to `ImageProcessing` protocol.
-public enum ImageProcessor {}
-
-// MARK: - ImageProcessor.Resize
-
-extension ImageProcessor {
- public enum Unit: CustomStringConvertible {
- case points
- case pixels
-
- public var description: String {
- switch self {
- case .points: return "points"
- case .pixels: return "pixels"
- }
- }
- }
-
- /// Scales an image to a specified size.
- public struct Resize: ImageProcessing, Hashable, CustomStringConvertible {
- private let size: CGSize
- private let unit: Unit
- private let contentMode: ContentMode
- private let crop: Bool
- private let upscale: Bool
-
- /// An option for how to resize the image.
- public enum ContentMode: CustomStringConvertible {
- /// Scales the image so that it completely fills the target area.
- /// Maintains the aspect ratio of the original image.
- case aspectFill
-
- /// Scales the image so that it fits the target size. Maintains the
- /// aspect ratio of the original image.
- case aspectFit
-
- public var description: String {
- switch self {
- case .aspectFill: return ".aspectFill"
- case .aspectFit: return ".aspectFill"
- }
- }
- }
-
- private var sizeInPixels: CGSize {
- return CGSize(size: size, unit: unit)
- }
-
- /// Initializes the processor with the given size.
- ///
- /// - parameter size: The target size.
- /// - parameter unit: Unit of the target size, `.points` by default.
- /// - parameter contentMode: `.aspectFill` by default.
- /// - parameter crop: If `true` will crop the image to match the target size. `false` by default.
- /// - parameter upscale: `false` by default.
- public init(size: CGSize, unit: Unit = .points, contentMode: ContentMode = .aspectFill, crop: Bool = false, upscale: Bool = false) {
- self.size = size
- self.unit = unit
- self.contentMode = contentMode
- self.crop = crop
- self.upscale = upscale
- }
-
- public func process(image: PlatformImage, context: ImageProcessingContext?) -> PlatformImage? {
- if crop && contentMode == .aspectFill {
- return image.processed.byResizingAndCropping(to: sizeInPixels)
- } else {
- return image.processed.byResizing(to: sizeInPixels, contentMode: contentMode, upscale: upscale)
- }
- }
-
- public var identifier: String {
- return "com.github.kean/nuke/resize?s=\(sizeInPixels),cm=\(contentMode),crop=\(crop),upscale=\(upscale)"
- }
-
- public var hashableIdentifier: AnyHashable {
- return self
- }
-
- public var description: String {
- return "Resize(size in \(unit): \(size), contentMode: \(contentMode), crop: \(crop), upscale: \(upscale))"
- }
- }
-}
-
-#if os(iOS) || os(tvOS) || os(watchOS)
-
-// MARK: - ImageProcessor.Circle
-
-extension ImageProcessor {
-
- /// Rounds the corners of an image into a circle.
- public struct Circle: ImageProcessing, Hashable, CustomStringConvertible {
- private let border: Border?
-
- public init(border: Border? = nil) {
- self.border = border
- }
-
- public func process(image: UIImage, context: ImageProcessingContext?) -> UIImage? {
- return image.processed.byDrawingInCircle(border: border)
- }
-
- public var identifier: String {
- if let border = self.border {
- return "com.github.kean/nuke/circle?border=\(border)"
- } else {
- return "com.github.kean/nuke/circle"
- }
- }
-
- public var hashableIdentifier: AnyHashable {
- return self
- }
-
- public var description: String {
- return "Circle"
- }
- }
-}
-
-// MARK: - ImageProcessor.RoundedCorners
-
-extension ImageProcessor {
- public struct Border: Hashable {
- let color: UIColor
- let width: CGFloat
-
- public init(color: UIColor, width: CGFloat = 1) {
- self.color = color
- self.width = width
- }
-
- public var description: String {
- return "Border(color: \(color), width: \(width))"
- }
- }
-
- /// Rounds the corners of an image to the specified radius.
- ///
- /// - warning: In order for the corners to be displayed correctly, the image must exactly match the size
- /// of the image view in which it will be displayed. See `ImageProcessor.Resize` for more info.
- public struct RoundedCorners: ImageProcessing, Hashable, CustomStringConvertible {
- private let radius: CGFloat
- private let unit: Unit
- private let border: ImageProcessor.Border?
-
- /// Initializes the processor with the given radius.
- ///
- /// - parameter radius: The radius of the corners.
- /// - parameter unit: Unit of the radius, `.points` by default.
- /// - parameter border: An optional border drawn around the image.
- public init(radius: CGFloat, unit: Unit = .points, border: ImageProcessor.Border? = nil) {
- self.radius = radius
- self.unit = unit
- self.border = border
- }
-
- public func process(image: UIImage, context: ImageProcessingContext?) -> UIImage? {
- return image.processed.byAddingRoundedCorners(radius: radius.converted(to: unit), border: border)
- }
-
- public var identifier: String {
- if let border = self.border {
- return "com.github.kean/nuke/rounded_corners?radius=\(radius.converted(to: unit)),border=\(border)"
- } else {
- return "com.github.kean/nuke/rounded_corners?radius=\(radius.converted(to: unit))"
- }
- }
-
- public var hashableIdentifier: AnyHashable {
- return self
- }
-
- public var description: String {
- return "RoundedCorners(radius in \(unit): \(radius))"
- }
- }
-}
-
-#if os(iOS) || os(tvOS)
-
-// MARK: - ImageProcessor.CoreImageFilter
-
-import CoreImage
-
-extension ImageProcessor {
-
- /// Applies Core Image filter (`CIFilter`) to the image.
- ///
- /// # Performance Considerations.
- ///
- /// Prefer chaining multiple `CIFilter` objects using `Core Image` facilities
- /// instead of using multiple instances of `ImageProcessor.CoreImageFilter`.
- ///
- /// # References
- ///
- /// - [Core Image Programming Guide](https://developer.apple.com/library/ios/documentation/GraphicsImaging/Conceptual/CoreImaging/ci_intro/ci_intro.html)
- /// - [Core Image Filter Reference](https://developer.apple.com/library/prerelease/ios/documentation/GraphicsImaging/Reference/CoreImageFilterReference/index.html)
- public struct CoreImageFilter: ImageProcessing, CustomStringConvertible {
- private let name: String
- private let parameters: [String: Any]
- public let identifier: String
-
- /// - parameter identifier: Uniquely identifies the processor.
- public init(name: String, parameters: [String: Any], identifier: String) {
- self.name = name
- self.parameters = parameters
- self.identifier = identifier
- }
-
- public init(name: String) {
- self.name = name
- self.parameters = [:]
- self.identifier = "com.github.kean/nuke/core_image?name=\(name))"
- }
-
- public func process(image: UIImage, context: ImageProcessingContext?) -> UIImage? {
- let filter = CIFilter(name: name, parameters: parameters)
- return CoreImageFilter.apply(filter: filter, to: image)
- }
-
- // MARK: - Apply Filter
-
- /// A default context shared between all Core Image filters. The context
- /// has `.priorityRequestLow` option set to `true`.
- public static var context = CIContext(options: [.priorityRequestLow: true])
-
- public static func apply(filter: CIFilter?, to image: UIImage) -> UIImage? {
- guard let filter = filter else {
- return nil
- }
- return applyFilter(to: image) {
- filter.setValue($0, forKey: kCIInputImageKey)
- return filter.outputImage
- }
- }
-
- static func applyFilter(to image: UIImage, context: CIContext = context, closure: (CoreImage.CIImage) -> CoreImage.CIImage?) -> UIImage? {
- let ciImage: CoreImage.CIImage? = {
- if let image = image.ciImage {
- return image
- }
- if let image = image.cgImage {
- return CoreImage.CIImage(cgImage: image)
- }
- return nil
- }()
- guard let inputImage = ciImage, let outputImage = closure(inputImage) else {
- return nil
- }
- guard let imageRef = context.createCGImage(outputImage, from: outputImage.extent) else {
- return nil
- }
- return UIImage(cgImage: imageRef, scale: image.scale, orientation: image.imageOrientation)
- }
-
- public var description: String {
- return "CoreImageFilter(name: \(name), parameters: \(parameters))"
- }
- }
-}
-
-// MARK: - ImageProcessor.GaussianBlur
-
-extension ImageProcessor {
- /// Blurs an image using `CIGaussianBlur` filter.
- public struct GaussianBlur: ImageProcessing, Hashable, CustomStringConvertible {
- private let radius: Int
-
- /// Initializes the receiver with a blur radius.
- public init(radius: Int = 8) {
- self.radius = radius
- }
-
- /// Applies `CIGaussianBlur` filter to the image.
- public func process(image: UIImage, context: ImageProcessingContext?) -> UIImage? {
- let filter = CIFilter(name: "CIGaussianBlur", parameters: ["inputRadius": radius])
- return CoreImageFilter.apply(filter: filter, to: image)
- }
-
- public var identifier: String {
- return "com.github.kean/nuke/gaussian_blur?radius=\(radius)"
- }
-
- public var hashableIdentifier: AnyHashable {
- return self
- }
-
- public var description: String {
- return "GaussianBlur(radius: \(radius))"
- }
- }
-}
-
-#endif
-
-// MARK: - ImageDecompression (Internal)
-
-struct ImageDecompression {
-
- func decompress(image: UIImage) -> UIImage {
- let output = image.decompressed() ?? image
- ImageDecompression.setDecompressionNeeded(false, for: output)
- return output
- }
-
- // MARK: Managing Decompression State
-
- static var isDecompressionNeededAK = "ImageDecompressor.isDecompressionNeeded.AssociatedKey"
-
- static func setDecompressionNeeded(_ isDecompressionNeeded: Bool, for image: UIImage) {
- objc_setAssociatedObject(image, &isDecompressionNeededAK, isDecompressionNeeded, .OBJC_ASSOCIATION_RETAIN)
- }
-
- static func isDecompressionNeeded(for image: UIImage) -> Bool? {
- return objc_getAssociatedObject(image, &isDecompressionNeededAK) as? Bool
- }
-}
-
-#endif
-
-// MARK: - ImageProcessor.Composition
-
-extension ImageProcessor {
- /// Composes multiple processors.
- public struct Composition: ImageProcessing, Hashable, CustomStringConvertible {
- let processors: [ImageProcessing]
-
- /// Composes multiple processors.
- public init(_ processors: [ImageProcessing]) {
- // note: multiple compositions are not flatten by default.
- self.processors = processors
- }
-
- /// Processes the given image by applying each processor in an order in
- /// which they were added. If one of the processors fails to produce
- /// an image the processing stops and `nil` is returned.
- public func process(image: PlatformImage, context: ImageProcessingContext?) -> PlatformImage? {
- return processors.reduce(image) { image, processor in
- return autoreleasepool {
- image.flatMap { processor.process(image: $0, context: context) }
- }
- }
- }
-
- public var identifier: String {
- return processors.map({ $0.identifier }).joined()
- }
-
- public var hashableIdentifier: AnyHashable {
- return self
- }
-
- public func hash(into hasher: inout Hasher) {
- for processor in processors {
- hasher.combine(processor.hashableIdentifier)
- }
- }
-
- public static func == (lhs: Composition, rhs: Composition) -> Bool {
- return lhs.processors == rhs.processors
- }
-
- public var description: String {
- return "Composition(processors: \(processors))"
- }
- }
-}
-
-// MARK: - ImageProcessor.Anonymous
-
-extension ImageProcessor {
- /// Processed an image using a specified closure.
- public struct Anonymous: ImageProcessing, CustomStringConvertible {
- public let identifier: String
- private let closure: (PlatformImage) -> PlatformImage?
-
- public init(id: String, _ closure: @escaping (PlatformImage) -> PlatformImage?) {
- self.identifier = id
- self.closure = closure
- }
-
- public func process(image: PlatformImage, context: ImageProcessingContext?) -> PlatformImage? {
- return self.closure(image)
- }
-
- public var description: String {
- return "AnonymousProcessor(identifier: \(identifier)"
- }
- }
-}
-
-// MARK: - Image Processing (Internal)
-
-extension PlatformImage {
- /// Draws the image in a `CGContext` in a canvas with the given size using
- /// the specified draw rect.
- ///
- /// For example, if the canvas size is `CGSize(width: 10, height: 10)` and
- /// the draw rect is `CGRect(x: -5, y: 0, width: 20, height: 10)` it would
- /// draw the input image (which is horizonal based on the known draw rect)
- /// in a square by centering it in the canvas.
- ///
- /// - parameter drawRect: `nil` by default. If `nil` will use the canvas rect.
- func draw(inCanvasWithSize canvasSize: CGSize, drawRect: CGRect? = nil) -> PlatformImage? {
- guard let cgImage = cgImage else {
- return nil
- }
-
- // For more info see:
- // - Quartz 2D Programming Guide
- // - https://github.com/kean/Nuke/issues/35
- // - https://github.com/kean/Nuke/issues/57
- let alphaInfo: CGImageAlphaInfo = cgImage.isOpaque ? .noneSkipLast : .premultipliedLast
-
- guard let ctx = CGContext(
- data: nil,
- width: Int(canvasSize.width), height: Int(canvasSize.height),
- bitsPerComponent: 8, bytesPerRow: 0,
- space: CGColorSpaceCreateDeviceRGB(),
- bitmapInfo: alphaInfo.rawValue) else {
- return nil
- }
- ctx.draw(cgImage, in: drawRect ?? CGRect(origin: .zero, size: canvasSize))
- guard let outputCGImage = ctx.makeImage() else {
- return nil
- }
- return PlatformImage.make(cgImage: outputCGImage, source: self)
- }
-
- /// Decompresses the input image by drawing in the the `CGContext`.
- func decompressed() -> PlatformImage? {
- guard let cgImage = cgImage else {
- return nil
- }
- return draw(inCanvasWithSize: cgImage.size, drawRect: CGRect(origin: .zero, size: cgImage.size))
- }
-}
-
-extension PlatformImage {
- var processed: ImageProcessingExtensions {
- return ImageProcessingExtensions(image: self)
- }
-}
-
-struct ImageProcessingExtensions {
- let image: PlatformImage
-
- func byResizing(to targetSize: CGSize,
- contentMode: ImageProcessor.Resize.ContentMode,
- upscale: Bool) -> PlatformImage? {
- guard let cgImage = image.cgImage else {
- return nil
- }
- let scale = contentMode == .aspectFill ?
- cgImage.size.scaleToFill(targetSize) :
- cgImage.size.scaleToFit(targetSize)
- guard scale < 1 || upscale else {
- return image // The image doesn't require scaling
- }
- let size = cgImage.size.scaled(by: scale).rounded()
- return image.draw(inCanvasWithSize: size)
- }
-
- /// Crops the input image to the given size and resizes it if needed.
- /// - note: this method will always upscale.
- func byResizingAndCropping(to targetSize: CGSize) -> PlatformImage? {
- guard let cgImage = image.cgImage else {
- return nil
- }
-
- let imageSize = cgImage.size
- let scaledSize = imageSize.scaled(by: cgImage.size.scaleToFill(targetSize))
- let drawRect = scaledSize.centeredInRectWithSize(targetSize)
- return image.draw(inCanvasWithSize: targetSize, drawRect: drawRect)
- }
-
- #if os(iOS) || os(tvOS) || os(watchOS)
-
- func byDrawingInCircle(border: ImageProcessor.Border?) -> UIImage? {
- guard let squared = byCroppingToSquare(), let cgImage = squared.cgImage else {
- return nil
- }
- let radius = CGFloat(cgImage.width) / 2.0 // Can use any dimenstion since image is a square
- return squared.processed.byAddingRoundedCorners(radius: radius, border: border)
- }
-
- /// Draws an image in square by preserving an aspect ratio and filling the
- /// square if needed. If the image is already a square, returns an original image.
- func byCroppingToSquare() -> UIImage? {
- guard let cgImage = image.cgImage else {
- return nil
- }
-
- guard cgImage.width != cgImage.height else {
- return image // Already a square
- }
-
- let imageSize = cgImage.size
- let side = min(cgImage.width, cgImage.height)
- let targetSize = CGSize(width: side, height: side)
- let cropRect = CGRect(origin: .zero, size: targetSize).offsetBy(
- dx: max(0, (imageSize.width - targetSize.width) / 2),
- dy: max(0, (imageSize.height - targetSize.height) / 2)
- )
- guard let cropped = cgImage.cropping(to: cropRect) else {
- return nil
- }
- return UIImage(cgImage: cropped, scale: image.scale, orientation: image.imageOrientation)
- }
-
- /// Adds rounded corners with the given radius to the image.
- /// - parameter radius: Radius in pixels.
- /// - parameter border: Optional stroke border.
- func byAddingRoundedCorners(radius: CGFloat, border: ImageProcessor.Border? = nil) -> UIImage? {
- guard let cgImage = image.cgImage else {
- return nil
- }
-
- let imageSize = cgImage.size
-
- UIGraphicsBeginImageContextWithOptions(imageSize, false, 1.0)
- defer { UIGraphicsEndImageContext() }
-
- let rect = CGRect(origin: CGPoint.zero, size: imageSize)
- let clippingPath = UIBezierPath(roundedRect: rect, cornerRadius: radius)
-
- clippingPath.addClip()
- image.draw(in: CGRect(origin: CGPoint.zero, size: imageSize))
-
- if let border = border, let context = UIGraphicsGetCurrentContext() {
- context.setStrokeColor(border.color.cgColor)
-
- let path = UIBezierPath(roundedRect: rect, cornerRadius: radius)
- path.lineWidth = border.width
-
- path.stroke()
- }
-
- guard let roundedImage = UIGraphicsGetImageFromCurrentImageContext()?.cgImage else {
- return nil
- }
-
- return UIImage(cgImage: roundedImage, scale: image.scale, orientation: image.imageOrientation)
- }
-
- #endif
-}
-
-// MARK: - CoreGraphics Helpers (Internal)
-
-#if os(macOS)
-extension NSImage {
- var cgImage: CGImage? {
- return cgImage(forProposedRect: nil, context: nil, hints: nil)
- }
-
- static func make(cgImage: CGImage, source: NSImage) -> NSImage {
- return NSImage(cgImage: cgImage, size: .zero)
- }
-}
-#else
-extension UIImage {
- static func make(cgImage: CGImage, source: UIImage) -> UIImage {
- return UIImage(cgImage: cgImage, scale: source.scale, orientation: source.imageOrientation)
- }
-}
-#endif
-
-extension CGImage {
- /// Returns `true` if the image doesn't contain alpha channel.
- var isOpaque: Bool {
- let alpha = alphaInfo
- return alpha == .none || alpha == .noneSkipFirst || alpha == .noneSkipLast
- }
-
- var size: CGSize {
- return CGSize(width: width, height: height)
- }
-}
-
-extension CGFloat {
- func converted(to unit: ImageProcessor.Unit) -> CGFloat {
- switch unit {
- case .pixels: return self
- case .points: return self * Screen.scale
- }
- }
-}
-
-extension CGSize: Hashable { // For some reason `CGSize` isn't `Hashable`
- public func hash(into hasher: inout Hasher) {
- hasher.combine(width)
- hasher.combine(height)
- }
-}
-
-extension CGSize {
- /// Creates the size in pixels by scaling to the input size to the screen scale
- /// if needed.
- init(size: CGSize, unit: ImageProcessor.Unit) {
- switch unit {
- case .pixels: self = size // The size is already in pixels
- case .points: self = size.scaled(by: Screen.scale)
- }
- }
-
- func scaled(by scale: CGFloat) -> CGSize {
- return CGSize(width: width * scale, height: height * scale)
- }
-
- func rounded() -> CGSize {
- return CGSize(width: CGFloat(round(width)), height: CGFloat(round(height)))
- }
-}
-
-extension CGSize {
- func scaleToFill(_ targetSize: CGSize) -> CGFloat {
- let scaleHor = targetSize.width / width
- let scaleVert = targetSize.height / height
- return max(scaleHor, scaleVert)
- }
-
- func scaleToFit(_ targetSize: CGSize) -> CGFloat {
- let scaleHor = targetSize.width / width
- let scaleVert = targetSize.height / height
- return min(scaleHor, scaleVert)
- }
-
- /// Caclulates a rect such that the ouput rect will be in the center of
- /// the rect of the input size (assuming origin: .zero)
- func centeredInRectWithSize(_ targetSize: CGSize) -> CGRect {
- // First, resize the original size to fill the target size.
- return CGRect(origin: .zero, size: self).offsetBy(
- dx: -(width - targetSize.width) / 2,
- dy: -(height - targetSize.height) / 2
- )
- }
-}
-
-// MARK: - ImageProcessing Extensions (Internal)
-
-// A special version of `==` which is optimized to not create hashable identifiers
-// when not necessary (e.g. one processor is `nil` and another one isn't.
-func == (lhs: ImageProcessing?, rhs: ImageProcessing?) -> Bool {
- switch (lhs, rhs) {
- case (.none, .none): return true
- case let (.some(lhs), .some(rhs)): return lhs.hashableIdentifier == rhs.hashableIdentifier
- default: return false
- }
-}
-
-func == (lhs: [ImageProcessing], rhs: [ImageProcessing]) -> Bool {
- guard lhs.count == rhs.count else {
- return false
- }
- // Lazily creates `hashableIdentifiers` because for some processors the
- // identifiers might be expensive to compute.
- return zip(lhs, rhs).allSatisfy {
- $0.hashableIdentifier == $1.hashableIdentifier
- }
-}
-
-// MARK: - Misc (Internal)
-
-struct Screen {
- #if os(iOS) || os(tvOS)
- /// Returns the current screen scale.
- static var scale: CGFloat {
- return UIScreen.main.scale
- }
- #elseif os(watchOS)
- /// Returns the current screen scale.
- static var scale: CGFloat {
- return WKInterfaceDevice.current().screenScale
- }
- #elseif os(macOS)
- /// Always returns 1.
- static var scale: CGFloat {
- return 1
- }
- #endif
-}
diff --git a/Pods/Nuke/Sources/ImageRequest.swift b/Pods/Nuke/Sources/ImageRequest.swift
deleted file mode 100644
index 28fa8bf..0000000
--- a/Pods/Nuke/Sources/ImageRequest.swift
+++ /dev/null
@@ -1,337 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-// MARK: - ImageRequest
-
-/// Represents an image request.
-public struct ImageRequest: CustomStringConvertible {
-
- // MARK: Parameters of the Request
-
- /// The `URLRequest` used for loading an image.
- public var urlRequest: URLRequest {
- get { return ref.resource.urlRequest }
- set {
- mutate {
- $0.resource = Resource.urlRequest(newValue)
- $0.urlString = newValue.url?.absoluteString
- }
- }
- }
-
- /// The execution priority of the request. The priority affects the order in which the image
- /// requests are executed.
- public enum Priority: Int, Comparable {
- case veryLow = 0, low, normal, high, veryHigh
-
- var queuePriority: Operation.QueuePriority {
- switch self {
- case .veryLow: return .veryLow
- case .low: return .low
- case .normal: return .normal
- case .high: return .high
- case .veryHigh: return .veryHigh
- }
- }
-
- public static func < (lhs: Priority, rhs: Priority) -> Bool {
- return lhs.rawValue < rhs.rawValue
- }
- }
-
- /// The relative priority of the operation. The priority affects the order in which the image
- /// requests are executed.`.normal` by default.
- public var priority: Priority {
- get { return ref.priority }
- set { mutate { $0.priority = newValue } }
- }
-
- /// The request options. See `ImageRequestOptions` for more info.
- public var options: ImageRequestOptions {
- get { return ref.options }
- set { mutate { $0.options = newValue } }
- }
-
- /// Processor to be applied to the image. `nil` by default.
- public var processors: [ImageProcessing] {
- get { return ref.processors }
- set { mutate { $0.processors = newValue } }
- }
-
- // MARK: Initializers
-
- /// Initializes a request with the given URL.
- ///
- /// - parameter priority: The priority of the request, `.normal` by default.
- /// - parameter options: Advanced image loading options.
- /// - parameter processors: Image processors to be applied after the image is loaded.
- ///
- /// `ImageRequest` allows you to set image processors, change the request priority and more:
- ///
- /// ```swift
- /// let request = ImageRequest(
- /// url: URL(string: "http://..."),
- /// processors: [ImageProcessor.Resize(size: imageView.bounds.size)],
- /// priority: .high
- /// )
- /// ```
- public init(url: URL,
- processors: [ImageProcessing] = [],
- priority: ImageRequest.Priority = .normal,
- options: ImageRequestOptions = .init()) {
- self.ref = Container(resource: Resource.url(url), processors: processors, priority: priority, options: options)
- self.ref.urlString = url.absoluteString
- // creating `.absoluteString` takes 50% of time of Request creation,
- // it's still faster than using URLs as cache keys
- }
-
- /// Initializes a request with the given request.
- ///
- /// - parameter priority: The priority of the request, `.normal` by default.
- /// - parameter options: Advanced image loading options.
- /// - parameter processors: Image processors to be applied after the image is loaded.
- ///
- /// `ImageRequest` allows you to set image processors, change the request priority and more:
- ///
- /// ```swift
- /// let request = ImageRequest(
- /// url: URL(string: "http://..."),
- /// processors: [ImageProcessor.Resize(size: imageView.bounds.size)],
- /// priority: .high
- /// )
- /// ```
- public init(urlRequest: URLRequest,
- processors: [ImageProcessing] = [],
- priority: ImageRequest.Priority = .normal,
- options: ImageRequestOptions = .init()) {
- self.ref = Container(resource: Resource.urlRequest(urlRequest), processors: processors, priority: priority, options: options)
- self.ref.urlString = urlRequest.url?.absoluteString
- }
-
- // CoW:
-
- private var ref: Container
-
- private mutating func mutate(_ closure: (Container) -> Void) {
- if !isKnownUniquelyReferenced(&ref) {
- ref = Container(container: ref)
- }
- closure(ref)
- }
-
- /// Just like many Swift built-in types, `ImageRequest` uses CoW approach to
- /// avoid memberwise retain/releases when `ImageRequest` is passed around.
- private class Container {
- var resource: Resource
- var urlString: String? // memoized absoluteString
- var priority: ImageRequest.Priority
- var options: ImageRequestOptions
- var processors: [ImageProcessing]
-
- /// Creates a resource with a default processor.
- init(resource: Resource, processors: [ImageProcessing], priority: Priority, options: ImageRequestOptions) {
- self.resource = resource
- self.priority = priority
- self.options = options
- self.processors = processors
- }
-
- /// Creates a copy.
- init(container ref: Container) {
- self.resource = ref.resource
- self.urlString = ref.urlString
- self.processors = ref.processors
- self.options = ref.options
- self.priority = ref.priority
- }
-
- var preferredURLString: String {
- return options.filteredURL ?? urlString ?? ""
- }
- }
-
- /// Resource representation (either URL or URLRequest).
- private enum Resource: CustomStringConvertible {
- case url(URL)
- case urlRequest(URLRequest)
-
- var urlRequest: URLRequest {
- switch self {
- case let .url(url): return URLRequest(url: url) // create lazily
- case let .urlRequest(urlRequest): return urlRequest
- }
- }
-
- var description: String {
- switch self {
- case let .url(url):
- return "\(url)"
- case let .urlRequest(urlRequest):
- return "\(urlRequest)"
- }
- }
- }
-
- public var description: String {
- return """
- ImageRequest {
- resource: \(ref.resource)
- priority: \(ref.priority)
- processors: \(ref.processors)
- options: {
- memoryCacheOptions: \(ref.options.memoryCacheOptions)
- filteredURL: \(String(describing: ref.options.filteredURL))
- cacheKey: \(String(describing: ref.options.cacheKey))
- loadKey: \(String(describing: ref.options.loadKey))
- userInfo: \(String(describing: ref.options.userInfo))
- }
- }
- """
- }
-}
-
-// MARK: - ImageRequestOptions (Advanced Options)
-
-public struct ImageRequestOptions {
- /// The policy to use when reading or writing images to the memory cache.
- public struct MemoryCacheOptions {
- /// `true` by default.
- public var isReadAllowed = true
-
- /// `true` by default.
- public var isWriteAllowed = true
-
- public init(isReadAllowed: Bool = true, isWriteAllowed: Bool = true) {
- self.isReadAllowed = isReadAllowed
- self.isWriteAllowed = isWriteAllowed
- }
- }
-
- /// `MemoryCacheOptions()` (read allowed, write allowed) by default.
- public var memoryCacheOptions: MemoryCacheOptions
-
- /// Provide a `filteredURL` to be used as a key for caching in case the original URL
- /// contains transient query parameters.
- ///
- /// ```
- /// let request = ImageRequest(
- /// url: URL(string: "http://example.com/image.jpeg?token=123")!,
- /// options: ImageRequestOptions(
- /// filteredURL: "http://example.com/image.jpeg"
- /// )
- /// )
- /// ```
- public var filteredURL: String?
-
- /// Returns a key that compares requests with regards to caching images.
- ///
- /// The default key considers two requests equivalent it they have the same
- /// `URLRequests` and the same processors. `URLRequests` are compared
- /// just by their `URLs`.
- public var cacheKey: AnyHashable?
-
- /// Returns a key that compares requests with regards to loading images.
- ///
- /// The default key considers two requests equivalent it they have the same
- /// `URLRequests` and the same processors. `URLRequests` are compared by
- /// their `URL`, `cachePolicy`, and `allowsCellularAccess` properties.
- public var loadKey: AnyHashable?
-
- /// Custom info passed alongside the request.
- public var userInfo: Any?
-
- public init(memoryCacheOptions: MemoryCacheOptions = .init(),
- filteredURL: String? = nil,
- cacheKey: AnyHashable? = nil,
- loadKey: AnyHashable? = nil,
- userInfo: Any? = nil) {
- self.memoryCacheOptions = memoryCacheOptions
- self.filteredURL = filteredURL
- self.cacheKey = cacheKey
- self.loadKey = loadKey
- self.userInfo = userInfo
- }
-}
-
-// MARK: - ImageRequestKeys (Internal)
-
-extension ImageRequest {
-
- // MARK: - Cache Keys
-
- /// A key for processed image in memory cache.
- func makeCacheKeyForProcessedImage() -> ImageRequest.CacheKey {
- return CacheKey(request: self)
- }
-
- /// A key for processed image data in disk cache.
- func makeCacheKeyForProcessedImageData() -> String {
- return ref.preferredURLString + ImageProcessor.Composition(processors).identifier
- }
-
- /// A key for original image data in disk cache.
- func makeCacheKeyForOriginalImageData() -> String {
- return ref.preferredURLString
- }
-
- // MARK: - Load Keys
-
- /// A key for deduplicating operations for fetching the processed image.
- func makeLoadKeyForProcessedImage() -> AnyHashable {
- return LoadKeyForProcessedImage(cacheKey: makeCacheKeyForProcessedImage(),
- loadKey: makeLoadKeyForOriginalImage())
- }
-
- /// A key for deduplicating operations for fetching the original image.
- func makeLoadKeyForOriginalImage() -> AnyHashable {
- if let loadKey = self.options.loadKey {
- return loadKey
- }
- return LoadKeyForOriginalImage(request: self)
- }
-
- // MARK: - Internals (Keys)
-
- // Uniquely identifies a cache processed image.
- struct CacheKey: Hashable {
- let request: ImageRequest
-
- func hash(into hasher: inout Hasher) {
- if let customKey = request.ref.options.cacheKey {
- hasher.combine(customKey)
- } else {
- hasher.combine(request.ref.preferredURLString)
- }
- }
-
- static func == (lhs: CacheKey, rhs: CacheKey) -> Bool {
- let lhs = lhs.request.ref, rhs = rhs.request.ref
- if lhs.options.cacheKey != nil || rhs.options.cacheKey != nil {
- return lhs.options.cacheKey == rhs.options.cacheKey
- }
- return lhs.preferredURLString == rhs.preferredURLString && lhs.processors == rhs.processors
- }
- }
-
- // Uniquely identifies a task of retrieving the processed image.
- private struct LoadKeyForProcessedImage: Hashable {
- let cacheKey: CacheKey
- let loadKey: AnyHashable
- }
-
- private struct LoadKeyForOriginalImage: Hashable {
- let urlString: String?
- let cachePolicy: URLRequest.CachePolicy
- let allowsCellularAccess: Bool
-
- init(request: ImageRequest) {
- self.urlString = request.ref.urlString
- let urlRequest = request.urlRequest
- self.cachePolicy = urlRequest.cachePolicy
- self.allowsCellularAccess = urlRequest.allowsCellularAccess
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImageTask.swift b/Pods/Nuke/Sources/ImageTask.swift
deleted file mode 100644
index 1d1b255..0000000
--- a/Pods/Nuke/Sources/ImageTask.swift
+++ /dev/null
@@ -1,151 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-#if !os(macOS)
-import UIKit.UIImage
-#else
-import AppKit.NSImage
-#endif
-
-// MARK: - ImageTask
-
-/// A task performed by the `ImagePipeline`. The pipeline maintains a strong
-/// reference to the task until the request finishes or fails; you do not need
-/// to maintain a reference to the task unless it is useful to do so for your
-/// app’s internal bookkeeping purposes.
-public /* final */ class ImageTask: Hashable, CustomStringConvertible {
- /// An identifier uniquely identifies the task within a given pipeline. Only
- /// unique within this pipeline.
- public let taskId: Int
-
- let isDataTask: Bool
-
- weak var pipeline: ImagePipeline?
-
- /// The original request with which the task was created.
- public let request: ImageRequest
-
- /// Updates the priority of the task, even if the task is already running.
- public var priority: ImageRequest.Priority {
- didSet {
- pipeline?.imageTaskUpdatePriorityCalled(self, priority: priority)
- }
- }
- var _priority: ImageRequest.Priority // Backing store for access from pipeline
-
- /// The number of bytes that the task has received.
- public internal(set) var completedUnitCount: Int64 = 0
-
- /// A best-guess upper bound on the number of bytes the client expects to send.
- public internal(set) var totalUnitCount: Int64 = 0
-
- /// Returns a progress object for the task. The object is created lazily.
- public var progress: Progress {
- if _progress == nil { _progress = Progress() }
- return _progress!
- }
- private(set) var _progress: Progress?
-
- var isCancelled: Bool {
- lock?.lock()
- defer { lock?.unlock() }
- return _isCancelled
- }
- private(set) var _isCancelled = false
- private let lock: NSLock?
-
- let queue: DispatchQueue?
-
- /// A completion handler to be called when task finishes or fails.
- public typealias Completion = (_ result: Result) -> Void
-
- /// A progress handler to be called periodically during the lifetime of a task.
- public typealias ProgressHandler = (_ intermediateResponse: ImageResponse?, _ completedUnitCount: Int64, _ totalUnitCount: Int64) -> Void
-
- init(taskId: Int, request: ImageRequest, isMainThreadConfined: Bool = false, isDataTask: Bool, queue: DispatchQueue?) {
- self.taskId = taskId
- self.request = request
- self._priority = request.priority
- self.priority = request.priority
- self.isDataTask = isDataTask
- self.queue = queue
- lock = isMainThreadConfined ? nil : NSLock()
- }
-
- /// Marks task as being cancelled.
- ///
- /// The pipeline will immediately cancel any work associated with a task
- /// unless there is an equivalent outstanding task running (see
- /// `ImagePipeline.Configuration.isDeduplicationEnabled` for more info).
- public func cancel() {
- if let lock = lock {
- lock.lock()
- defer { lock.unlock() }
- _cancel()
- } else {
- assert(Thread.isMainThread, "Must be cancelled only from the main thread")
- _cancel()
- }
- }
-
- private func _cancel() {
- if !_isCancelled {
- _isCancelled = true
- pipeline?.imageTaskCancelCalled(self)
- }
- }
-
- // MARK: - Internal
-
- func setProgress(_ progress: TaskProgress) {
- completedUnitCount = progress.completed
- totalUnitCount = progress.total
- _progress?.completedUnitCount = progress.completed
- _progress?.totalUnitCount = progress.total
- }
-
- // MARK: - Hashable
-
- public func hash(into hasher: inout Hasher) {
- hasher.combine(ObjectIdentifier(self).hashValue)
- }
-
- public static func == (lhs: ImageTask, rhs: ImageTask) -> Bool {
- return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
- }
-
- // MARK: - CustomStringConvertible
-
- public var description: String {
- return "ImageTask(id: \(taskId), priority: \(priority), completedUnitCount: \(completedUnitCount), totalUnitCount: \(totalUnitCount), isCancelled: \(isCancelled))"
- }
-}
-
-// MARK: - ImageResponse
-
-/// Represents an image response.
-public final class ImageResponse {
- public let image: PlatformImage
- public let urlResponse: URLResponse?
- // the response is only nil when new disk cache is enabled (it only stores
- // data for now, but this might change in the future).
- public let scanNumber: Int?
-
- public init(image: PlatformImage, urlResponse: URLResponse? = nil, scanNumber: Int? = nil) {
- self.image = image
- self.urlResponse = urlResponse
- self.scanNumber = scanNumber
- }
-
- func map(_ transformation: (PlatformImage) -> PlatformImage?) -> ImageResponse? {
- return autoreleasepool {
- guard let output = transformation(image) else {
- return nil
- }
- return ImageResponse(image: output, urlResponse: urlResponse, scanNumber: scanNumber)
- }
- }
-}
diff --git a/Pods/Nuke/Sources/ImageViewExtensions.swift b/Pods/Nuke/Sources/ImageViewExtensions.swift
deleted file mode 100644
index 7c69f2a..0000000
--- a/Pods/Nuke/Sources/ImageViewExtensions.swift
+++ /dev/null
@@ -1,575 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-#if !os(macOS)
-import UIKit.UIImage
-/// Alias for `UIImage`.
-public typealias PlatformImage = UIImage
-#else
-import AppKit.NSImage
-/// Alias for `NSImage`.
-public typealias PlatformImage = NSImage
-#endif
-
-/// Displays images. Add the conformance to this protocol to your views to make
-/// them compatible with Nuke image loading extensions.
-///
-/// The protocol is defined as `@objc` to make it possible to override its
-/// methods in extensions (e.g. you can override `nuke_display(image:)` in/
-// `UIImageView` subclass like `Gifu.ImageView).
-///
-/// The protocol and its methods have prefixes to make sure they don't clash
-/// with other similar methods and protocol in Objective-C runtime.
-@objc public protocol Nuke_ImageDisplaying {
- /// Display a given image.
- @objc func nuke_display(image: PlatformImage?)
-}
-
-#if os(iOS) || os(tvOS)
-import UIKit
-/// A `UIView` that implements `ImageDisplaying` protocol.
-public typealias ImageDisplayingView = UIView & Nuke_ImageDisplaying
-
-extension UIImageView: Nuke_ImageDisplaying {
- /// Displays an image.
- open func nuke_display(image: UIImage?) {
- self.image = image
- }
-}
-#elseif os(macOS)
-import Cocoa
-/// An `NSView` that implements `ImageDisplaying` protocol.
-public typealias ImageDisplayingView = NSView & Nuke_ImageDisplaying
-
-extension NSImageView: Nuke_ImageDisplaying {
- /// Displays an image.
- open func nuke_display(image: NSImage?) {
- self.image = image
- }
-}
-#elseif os(watchOS)
-import WatchKit
-
-/// An `NSView` that implements `ImageDisplaying` protocol.
-public typealias ImageDisplayingView = WKInterfaceObject & Nuke_ImageDisplaying
-
-extension WKInterfaceImage: Nuke_ImageDisplaying {
- /// Displays an image.
- open func nuke_display(image: UIImage?) {
- self.setImage(image)
- }
-}
-#endif
-
-// MARK: - ImageView Extensions
-
-/// Loads an image with the given URL and displays it in the view.
-///
-/// Before loading a new image, the view is prepared for reuse by canceling any
-/// outstanding requests and removing a previously displayed image.
-///
-/// If the image is stored in the memory cache, it is displayed immediately. If not,
-/// the image is loaded using an image pipeline. When the image is loading, the provided
-/// `placeholder` is displayed. When the request completes the loaded image is displayed
-/// (or `failureImage` in case of an error) with the provided transition.
-///
-/// - parameter options: `ImageLoadingOptions.shared` by default.
-/// - parameter view: Nuke keeps a weak reference to the view. If the view is deallocated
-/// the associated request automatically gets canceled.
-/// - parameter progress: A closure to be called periodically on the main thread
-/// when the progress is updated. `nil` by default.
-/// - parameter completion: A closure to be called on the main thread when the
-/// request is finished. Gets called synchronously if the response was found in
-/// the memory cache. `nil` by default.
-/// - returns: An image task or `nil` if the image was found in the memory cache.
-@discardableResult
-public func loadImage(with url: URL,
- options: ImageLoadingOptions = ImageLoadingOptions.shared,
- into view: ImageDisplayingView,
- progress: ImageTask.ProgressHandler? = nil,
- completion: ImageTask.Completion? = nil) -> ImageTask? {
- return loadImage(with: ImageRequest(url: url), options: options, into: view, progress: progress, completion: completion)
-}
-
-/// Loads an image with the given request and displays it in the view.
-///
-/// Before loading a new image, the view is prepared for reuse by canceling any
-/// outstanding requests and removing a previously displayed image.
-///
-/// If the image is stored in the memory cache, it is displayed immediately. If not,
-/// the image is loaded using an image pipeline. When the image is loading, the provided
-/// `placeholder` is displayed. When the request completes the loaded image is displayed
-/// (or `failureImage` in case of an error) with the provided transition.
-///
-/// - parameter options: `ImageLoadingOptions.shared` by default.
-/// - parameter view: Nuke keeps a weak reference to the view. If the view is deallocated
-/// the associated request automatically gets canceled.
-/// - parameter progress: A closure to be called periodically on the main thread
-/// when the progress is updated. `nil` by default.
-/// - parameter completion: A closure to be called on the main thread when the
-/// request is finished. Gets called synchronously if the response was found in
-/// the memory cache. `nil` by default.
-/// - returns: An image task or `nil` if the image was found in the memory cache.
-@discardableResult
-public func loadImage(with request: ImageRequest,
- options: ImageLoadingOptions = ImageLoadingOptions.shared,
- into view: ImageDisplayingView,
- progress: ImageTask.ProgressHandler? = nil,
- completion: ImageTask.Completion? = nil) -> ImageTask? {
- assert(Thread.isMainThread)
- let controller = ImageViewController.controller(for: view)
- return controller.loadImage(with: request, options: options, progress: progress, completion: completion)
-}
-
-/// Cancels an outstanding request associated with the view.
-public func cancelRequest(for view: ImageDisplayingView) {
- assert(Thread.isMainThread)
- ImageViewController.controller(for: view).cancelOutstandingTask()
-}
-
-// MARK: - ImageLoadingOptions
-
-/// A range of options that control how the image is loaded and displayed.
-public struct ImageLoadingOptions {
- /// Shared options.
- public static var shared = ImageLoadingOptions()
-
- /// Placeholder to be displayed when the image is loading. `nil` by default.
- public var placeholder: PlatformImage?
-
- /// Image to be displayed when the request fails. `nil` by default.
- public var failureImage: PlatformImage?
-
- #if os(iOS) || os(tvOS) || os(macOS)
-
- /// The image transition animation performed when displaying a loaded image.
- /// Only runs when the image was not found in memory cache. `.nil` by default.
- public var transition: Transition?
-
- /// The image transition animation performed when displaying a failure image.
- /// `.nil` by default.
- public var failureImageTransition: Transition?
-
- /// If true, the requested image will always appear with transition, even
- /// when loaded from cache
- public var alwaysTransition = false
-
- #endif
-
- /// If true, every time you request a new image for a view, the view will be
- /// automatically prepared for reuse: image will be set to `nil`, and animations
- /// will be removed. `true` by default.
- public var isPrepareForReuseEnabled = true
-
- /// Custom pipeline to be used. `nil` by default.
- public var pipeline: ImagePipeline?
-
- #if os(iOS) || os(tvOS)
-
- /// Content modes to be used for each image type (placeholder, success,
- /// failure). `nil` by default (don't change content mode).
- public var contentModes: ContentModes?
-
- /// Custom content modes to be used for each image type (placeholder, success,
- /// failure).
- public struct ContentModes {
- /// Content mode to be used for the loaded image.
- public var success: UIView.ContentMode
- /// Content mode to be used when displaying a `failureImage`.
- public var failure: UIView.ContentMode
- /// Content mode to be used when displaying a `placeholder`.
- public var placeholder: UIView.ContentMode
-
- /// - parameter success: A content mode to be used with a loaded image.
- /// - parameter failure: A content mode to be used with a `failureImage`.
- /// - parameter placeholder: A content mode to be used with a `placeholder`.
- public init(success: UIView.ContentMode, failure: UIView.ContentMode, placeholder: UIView.ContentMode) {
- self.success = success; self.failure = failure; self.placeholder = placeholder
- }
- }
-
- #endif
-
- #if os(iOS) || os(tvOS)
-
- /// - parameter placeholder: Placeholder to be displayed when the image is
- /// loading . `nil` by default.
- /// - parameter transision: The image transition animation performed when
- /// displaying a loaded image. Only runs when the image was not found in
- /// memory cache `.nil` by default (no animations).
- /// - parameter failureImage: Image to be displayd when request fails.
- /// `nil` by default.
- /// - parameter failureImageTransition: The image transition animation
- /// performed when displaying a failure image. `.nil` by default.
- /// - parameter contentModes: Content modes to be used for each image type
- /// (placeholder, success, failure). `nil` by default (don't change content mode).
- public init(placeholder: UIImage? = nil, transition: Transition? = nil, failureImage: UIImage? = nil, failureImageTransition: Transition? = nil, contentModes: ContentModes? = nil) {
- self.placeholder = placeholder
- self.transition = transition
- self.failureImage = failureImage
- self.failureImageTransition = failureImageTransition
- self.contentModes = contentModes
- }
-
- #elseif os(macOS)
-
- public init(placeholder: NSImage? = nil, transition: Transition? = nil, failureImage: NSImage? = nil, failureImageTransition: Transition? = nil) {
- self.placeholder = placeholder
- self.transition = transition
- self.failureImage = failureImage
- self.failureImageTransition = failureImageTransition
- }
-
- #elseif os(watchOS)
-
- public init(placeholder: UIImage? = nil, failureImage: UIImage? = nil) {
- self.placeholder = placeholder
- self.failureImage = failureImage
- }
-
- #endif
-
- #if os(iOS) || os(tvOS)
-
- /// An animated image transition.
- public struct Transition {
- var style: Style
-
- enum Style { // internal representation
- case fadeIn(parameters: Parameters)
- case custom((ImageDisplayingView, UIImage) -> Void)
- }
-
- struct Parameters { // internal representation
- let duration: TimeInterval
- let options: UIView.AnimationOptions
- }
-
- /// Fade-in transition (cross-fade in case the image view is already
- /// displaying an image).
- public static func fadeIn(duration: TimeInterval, options: UIView.AnimationOptions = .allowUserInteraction) -> Transition {
- return Transition(style: .fadeIn(parameters: Parameters(duration: duration, options: options)))
- }
-
- /// Custom transition. Only runs when the image was not found in memory cache.
- public static func custom(_ closure: @escaping (ImageDisplayingView, UIImage) -> Void) -> Transition {
- return Transition(style: .custom(closure))
- }
- }
-
- #elseif os(macOS)
-
- /// An animated image transition.
- public struct Transition {
- var style: Style
-
- enum Style { // internal representation
- case fadeIn(parameters: Parameters)
- case custom((ImageDisplayingView, NSImage) -> Void)
- }
-
- struct Parameters { // internal representation
- let duration: TimeInterval
- }
-
- /// Fade-in transition.
- public static func fadeIn(duration: TimeInterval) -> Transition {
- return Transition(style: .fadeIn(parameters: Parameters(duration: duration)))
- }
-
- /// Custom transition. Only runs when the image was not found in memory cache.
- public static func custom(_ closure: @escaping (ImageDisplayingView, NSImage) -> Void) -> Transition {
- return Transition(style: .custom(closure))
- }
- }
-
- #endif
-
- public init() {}
-}
-
-// MARK: - ImageViewController
-
-/// Manages image requests on behalf of an image view.
-///
-/// - note: With a few modifications this might become public at some point,
-/// however as it stands today `ImageViewController` is just a helper class,
-/// making it public wouldn't expose any additional functionality to the users.
-private final class ImageViewController {
- // Ideally should be `unowned` but can't because of the Swift bug
- // https://bugs.swift.org/browse/SR-7369
- private weak var imageView: ImageDisplayingView?
- private var task: ImageTask?
-
- // Automatically cancel the request when the view is deallocated.
- deinit {
- cancelOutstandingTask()
- }
-
- init(view: /* weak */ ImageDisplayingView) {
- self.imageView = view
- }
-
- // MARK: - Associating Controller
-
- static var controllerAK = "ImageViewController.AssociatedKey"
-
- // Lazily create a controller for a given view and associate it with a view.
- static func controller(for view: ImageDisplayingView) -> ImageViewController {
- if let controller = objc_getAssociatedObject(view, &ImageViewController.controllerAK) as? ImageViewController {
- return controller
- }
- let controller = ImageViewController(view: view)
- objc_setAssociatedObject(view, &ImageViewController.controllerAK, controller, .OBJC_ASSOCIATION_RETAIN)
- return controller
- }
-
- // MARK: - Loading Images
-
- func loadImage(with request: ImageRequest,
- options: ImageLoadingOptions,
- progress progressHandler: ImageTask.ProgressHandler? = nil,
- completion: ImageTask.Completion? = nil) -> ImageTask? {
- cancelOutstandingTask()
-
- guard let imageView = imageView else {
- return nil
- }
-
- if options.isPrepareForReuseEnabled { // enabled by default
- #if os(iOS) || os(tvOS)
- imageView.layer.removeAllAnimations()
- #elseif os(macOS)
- imageView.layer?.removeAllAnimations()
- #endif
- }
-
- let pipeline = options.pipeline ?? ImagePipeline.shared
-
- // Quick synchronous memory cache lookup
- if let response = pipeline.cachedResponse(for: request) {
- handle(result: .success(response), fromMemCache: true, options: options)
- completion?(.success(response))
- return nil
- }
-
- // Display a placeholder.
- if let placeholder = options.placeholder {
- imageView.nuke_display(image: placeholder)
- #if os(iOS) || os(tvOS)
- if let contentMode = options.contentModes?.placeholder {
- imageView.contentMode = contentMode
- }
- #endif
- } else if options.isPrepareForReuseEnabled {
- imageView.nuke_display(image: nil) // Remove previously displayed images (if any)
- }
-
- // Uses a special internal API (`isMainThreadConfined`) for performance
- // reasons, it attributes for about than 20% performance improvement.
- task = pipeline.loadImage(with: request, isMainThreadConfined: true, queue: .main) { [weak self] task, event in
- switch event {
- case .progress:
- progressHandler?(nil, task.completedUnitCount, task.totalUnitCount)
- case let .value(response, isCompleted):
- if isCompleted {
- self?.handle(result: .success(response), fromMemCache: false, options: options)
- completion?(.success(response))
- } else {
- self?.handle(partialImage: response, options: options)
- progressHandler?(response, task.completedUnitCount, task.totalUnitCount)
- }
- case let .error(error):
- self?.handle(result: .failure(error), fromMemCache: false, options: options)
- completion?(.failure(error))
- }
- }
- return task
- }
-
- func cancelOutstandingTask() {
- task?.cancel() // The pipeline guarantees no callbacks to be deliver after cancellation
- task = nil
- }
-
- // MARK: - Handling Responses
-
- #if os(iOS) || os(tvOS)
-
- private func handle(result: Result, fromMemCache: Bool, options: ImageLoadingOptions) {
- switch result {
- case let .success(response):
- display(response.image, options.transition, options.alwaysTransition, fromMemCache, options.contentModes?.success)
- case .failure:
- if let failureImage = options.failureImage {
- display(failureImage, options.failureImageTransition, options.alwaysTransition, fromMemCache, options.contentModes?.failure)
- }
- }
- self.task = nil
- }
-
- private func handle(partialImage response: ImageResponse, options: ImageLoadingOptions) {
- display(response.image, options.transition, options.alwaysTransition, false, options.contentModes?.success)
- }
-
- private func display(_ image: UIImage, _ transition: ImageLoadingOptions.Transition?, _ alwaysTransition: Bool, _ fromMemCache: Bool, _ newContentMode: UIView.ContentMode?) {
- guard let imageView = imageView else {
- return
- }
-
- if !fromMemCache || alwaysTransition, let transition = transition {
- switch transition.style {
- case let .fadeIn(params):
- runFadeInTransition(image: image, params: params, contentMode: newContentMode)
- case let .custom(closure):
- // The user is reponsible for both displaying an image and performing
- // animations.
- closure(imageView, image)
- }
- } else {
- imageView.nuke_display(image: image)
- }
- if let newContentMode = newContentMode {
- imageView.contentMode = newContentMode
- }
- }
-
- // Image view used for cross-fade transition between images with different
- // content modes.
- private lazy var transitionImageView = UIImageView()
-
- private func runFadeInTransition(image: UIImage, params: ImageLoadingOptions.Transition.Parameters, contentMode: UIView.ContentMode?) {
- guard let imageView = imageView else {
- return
- }
-
- // Special case where it animates between content modes, only works
- // on imageView subclasses.
- if let contentMode = contentMode, imageView.contentMode != contentMode, let imageView = imageView as? UIImageView, imageView.image != nil {
- runCrossDissolveWithContentMode(imageView: imageView, image: image, params: params)
- } else {
- runSimpleFadeIn(image: image, params: params)
- }
- }
-
- private func runSimpleFadeIn(image: UIImage, params: ImageLoadingOptions.Transition.Parameters) {
- guard let imageView = imageView else {
- return
- }
-
- UIView.transition(
- with: imageView,
- duration: params.duration,
- options: params.options.union(.transitionCrossDissolve),
- animations: {
- imageView.nuke_display(image: image)
- },
- completion: nil
- )
- }
-
- /// Performs cross-dissolve animation alonside transition to a new content
- /// mode. This isn't natively supported feature and it requires a second
- /// image view. There might be better ways to implement it.
- private func runCrossDissolveWithContentMode(imageView: UIImageView, image: UIImage, params: ImageLoadingOptions.Transition.Parameters) {
- // Lazily create a transition view.
- let transitionView = self.transitionImageView
-
- // Create a transition view which mimics current view's contents.
- transitionView.image = imageView.image
- transitionView.contentMode = imageView.contentMode
- imageView.addSubview(transitionView)
- transitionView.frame = imageView.bounds
-
- // "Manual" cross-fade.
- transitionView.alpha = 1
- imageView.alpha = 0
- imageView.image = image // Display new image in current view
-
- UIView.animate(
- withDuration: params.duration,
- delay: 0,
- options: params.options,
- animations: {
- transitionView.alpha = 0
- imageView.alpha = 1
- },
- completion: { isCompleted in
- if isCompleted {
- transitionView.removeFromSuperview()
- }
- }
- )
- }
-
- #elseif os(macOS)
-
- private func handle(result: Result, fromMemCache: Bool, options: ImageLoadingOptions) {
- // NSImageView doesn't support content mode, unfortunately.
- switch result {
- case let .success(response):
- display(response.image, options.transition, options.alwaysTransition, fromMemCache)
- case .failure:
- if let failureImage = options.failureImage {
- display(failureImage, options.failureImageTransition, options.alwaysTransition, fromMemCache)
- }
- }
- self.task = nil
- }
-
- private func handle(partialImage response: ImageResponse, options: ImageLoadingOptions) {
- display(response.image, options.transition, options.alwaysTransition, false)
- }
-
- private func display(_ image: NSImage, _ transition: ImageLoadingOptions.Transition?, _ alwaysTransition: Bool, _ fromMemCache: Bool) {
- guard let imageView = imageView else {
- return
- }
-
- if !fromMemCache || alwaysTransition, let transition = transition {
- switch transition.style {
- case let .fadeIn(params):
- runFadeInTransition(image: image, params: params)
- case let .custom(closure):
- // The user is reponsible for both displaying an image and performing
- // animations.
- closure(imageView, image)
- }
- } else {
- imageView.nuke_display(image: image)
- }
- }
-
- private func runFadeInTransition(image: NSImage, params: ImageLoadingOptions.Transition.Parameters) {
- let animation = CABasicAnimation(keyPath: "opacity")
- animation.duration = params.duration
- animation.fromValue = 0
- animation.toValue = 1
- imageView?.layer?.add(animation, forKey: "imageTransition")
-
- imageView?.nuke_display(image: image)
- }
-
- #elseif os(watchOS)
-
- private func handle(result: Result, fromMemCache: Bool, options: ImageLoadingOptions) {
- switch result {
- case let .success(response):
- imageView?.nuke_display(image: response.image)
- case .failure:
- if let failureImage = options.failureImage {
- imageView?.nuke_display(image: failureImage)
- }
- }
- self.task = nil
- }
-
- private func handle(partialImage response: ImageResponse, options: ImageLoadingOptions) {
- imageView?.nuke_display(image: response.image)
- }
-
- #endif
-}
diff --git a/Pods/Nuke/Sources/Internal.swift b/Pods/Nuke/Sources/Internal.swift
deleted file mode 100644
index 7a5a9d1..0000000
--- a/Pods/Nuke/Sources/Internal.swift
+++ /dev/null
@@ -1,474 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-import os
-
-// MARK: - Lock
-
-extension NSLock {
- func sync(_ closure: () -> T) -> T {
- lock(); defer { unlock() }
- return closure()
- }
-}
-
-// MARK: - RateLimiter
-
-/// Controls the rate at which the work is executed. Uses the classic [token
-/// bucket](https://en.wikipedia.org/wiki/Token_bucket) algorithm.
-///
-/// The main use case for rate limiter is to support large (infinite) collections
-/// of images by preventing trashing of underlying systems, primary URLSession.
-///
-/// The implementation supports quick bursts of requests which can be executed
-/// without any delays when "the bucket is full". This is important to prevent
-/// rate limiter from affecting "normal" requests flow.
-final class RateLimiter {
- private let bucket: TokenBucket
- private let queue: DispatchQueue
- private var pending = LinkedList() // fast append, fast remove first
- private var isExecutingPendingTasks = false
-
- typealias Work = () -> Bool
-
- /// Initializes the `RateLimiter` with the given configuration.
- /// - parameter queue: Queue on which to execute pending tasks.
- /// - parameter rate: Maximum number of requests per second. 80 by default.
- /// - parameter burst: Maximum number of requests which can be executed without
- /// any delays when "bucket is full". 25 by default.
- init(queue: DispatchQueue, rate: Int = 80, burst: Int = 25) {
- self.queue = queue
- self.bucket = TokenBucket(rate: Double(rate), burst: Double(burst))
- }
-
- /// - parameter closure: Returns `true` if the close was executed, `false`
- /// if the work was cancelled.
- func execute( _ work: @escaping Work) {
- if !pending.isEmpty || !bucket.execute(work) {
- pending.append(work)
- setNeedsExecutePendingTasks()
- }
- }
-
- private func setNeedsExecutePendingTasks() {
- guard !isExecutingPendingTasks else {
- return
- }
- isExecutingPendingTasks = true
- // Compute a delay such that by the time the closure is executed the
- // bucket is refilled to a point that is able to execute at least one
- // pending task. With a rate of 100 tasks we expect a refill every 10 ms.
- let delay = Int(1.15 * (1000 / bucket.rate)) // 14 ms for rate 80 (default)
- let bounds = max(100, min(5, delay)) // Make the delay is reasonable
- queue.asyncAfter(deadline: .now() + .milliseconds(bounds), execute: executePendingTasks)
- }
-
- private func executePendingTasks() {
- while let node = pending.first, bucket.execute(node.value) {
- pending.remove(node)
- }
- isExecutingPendingTasks = false
- if !pending.isEmpty { // Not all pending items were executed
- setNeedsExecutePendingTasks()
- }
- }
-}
-
-private final class TokenBucket {
- let rate: Double
- private let burst: Double // maximum bucket size
- private var bucket: Double
- private var timestamp: TimeInterval // last refill timestamp
-
- /// - parameter rate: Rate (tokens/second) at which bucket is refilled.
- /// - parameter burst: Bucket size (maximum number of tokens).
- init(rate: Double, burst: Double) {
- self.rate = rate
- self.burst = burst
- self.bucket = burst
- self.timestamp = CFAbsoluteTimeGetCurrent()
- }
-
- /// Returns `true` if the closure was executed, `false` if dropped.
- func execute(_ work: () -> Bool) -> Bool {
- refill()
- guard bucket >= 1.0 else {
- return false // bucket is empty
- }
- if work() {
- bucket -= 1.0 // work was cancelled, no need to reduce the bucket
- }
- return true
- }
-
- private func refill() {
- let now = CFAbsoluteTimeGetCurrent()
- bucket += rate * max(0, now - timestamp) // rate * (time delta)
- timestamp = now
- if bucket > burst { // prevent bucket overflow
- bucket = burst
- }
- }
-}
-
-// MARK: - Operation
-
-final class Operation: Foundation.Operation {
- private var _isExecuting = false
- private var _isFinished = false
- private var isFinishCalled = Atomic(false)
-
- override var isExecuting: Bool {
- set {
- guard _isExecuting != newValue else {
- fatalError("Invalid state, operation is already (not) executing")
- }
- willChangeValue(forKey: "isExecuting")
- _isExecuting = newValue
- didChangeValue(forKey: "isExecuting")
- }
- get {
- return _isExecuting
- }
- }
- override var isFinished: Bool {
- set {
- guard !_isFinished else {
- fatalError("Invalid state, operation is already finished")
- }
- willChangeValue(forKey: "isFinished")
- _isFinished = newValue
- didChangeValue(forKey: "isFinished")
- }
- get {
- return _isFinished
- }
- }
-
- typealias Starter = (_ finish: @escaping () -> Void) -> Void
- private let starter: Starter
-
- init(starter: @escaping Starter) {
- self.starter = starter
- }
-
- override func start() {
- guard !isCancelled else {
- isFinished = true
- return
- }
- isExecuting = true
- starter { [weak self] in
- self?._finish()
- }
- }
-
- private func _finish() {
- // Make sure that we ignore if `finish` is called more than once.
- if isFinishCalled.swap(to: true, ifEqual: false) {
- isExecuting = false
- isFinished = true
- }
- }
-}
-
-// MARK: - LinkedList
-
-/// A doubly linked list.
-final class LinkedList {
- // first <-> node <-> ... <-> last
- private(set) var first: Node?
- private(set) var last: Node?
-
- deinit {
- removeAll()
- }
-
- var isEmpty: Bool {
- return last == nil
- }
-
- /// Adds an element to the end of the list.
- @discardableResult
- func append(_ element: Element) -> Node {
- let node = Node(value: element)
- append(node)
- return node
- }
-
- /// Adds a node to the end of the list.
- func append(_ node: Node) {
- if let last = last {
- last.next = node
- node.previous = last
- self.last = node
- } else {
- last = node
- first = node
- }
- }
-
- func remove(_ node: Node) {
- node.next?.previous = node.previous // node.previous is nil if node=first
- node.previous?.next = node.next // node.next is nil if node=last
- if node === last {
- last = node.previous
- }
- if node === first {
- first = node.next
- }
- node.next = nil
- node.previous = nil
- }
-
- func removeAll() {
- // avoid recursive Nodes deallocation
- var node = first
- while let next = node?.next {
- node?.next = nil
- next.previous = nil
- node = next
- }
- last = nil
- first = nil
- }
-
- final class Node {
- let value: Element
- fileprivate var next: Node?
- fileprivate var previous: Node?
-
- init(value: Element) {
- self.value = value
- }
- }
-}
-
-// MARK: - ResumableData
-
-/// Resumable data support. For more info see:
-/// - https://developer.apple.com/library/content/qa/qa1761/_index.html
-struct ResumableData {
- let data: Data
- let validator: String // Either Last-Modified or ETag
-
- init?(response: URLResponse, data: Data) {
- // Check if "Accept-Ranges" is present and the response is valid.
- guard !data.isEmpty,
- let response = response as? HTTPURLResponse,
- response.statusCode == 200 /* OK */ || response.statusCode == 206, /* Partial Content */
- let acceptRanges = response.allHeaderFields["Accept-Ranges"] as? String,
- acceptRanges.lowercased() == "bytes",
- let validator = ResumableData._validator(from: response) else {
- return nil
- }
-
- // NOTE: https://developer.apple.com/documentation/foundation/httpurlresponse/1417930-allheaderfields
- // HTTP headers are case insensitive. To simplify your code, certain
- // header field names are canonicalized into their standard form.
- // For example, if the server sends a content-length header,
- // it is automatically adjusted to be Content-Length.
-
- self.data = data; self.validator = validator
- }
-
- private static func _validator(from response: HTTPURLResponse) -> String? {
- if let entityTag = response.allHeaderFields["ETag"] as? String {
- return entityTag // Prefer ETag
- }
- // There seems to be a bug with ETag where HTTPURLResponse would canonicalize
- // it to Etag instead of ETag
- // https://bugs.swift.org/browse/SR-2429
- if let entityTag = response.allHeaderFields["Etag"] as? String {
- return entityTag // Prefer ETag
- }
- if let lastModified = response.allHeaderFields["Last-Modified"] as? String {
- return lastModified
- }
- return nil
- }
-
- func resume(request: inout URLRequest) {
- var headers = request.allHTTPHeaderFields ?? [:]
- // "bytes=1000-" means bytes from 1000 up to the end (inclusive)
- headers["Range"] = "bytes=\(data.count)-"
- headers["If-Range"] = validator
- request.allHTTPHeaderFields = headers
- }
-
- // Check if the server decided to resume the response.
- static func isResumedResponse(_ response: URLResponse) -> Bool {
- // "206 Partial Content" (server accepted "If-Range")
- return (response as? HTTPURLResponse)?.statusCode == 206
- }
-
- // MARK: Storing Resumable Data
-
- /// Shared between multiple pipelines. Thread safe. In the future version we
- /// might feature more customization options.
- static var cache = Cache(costLimit: 32 * 1024 * 1024, countLimit: 100)
- // internal only for testing purposes
-
- static func removeResumableData(for request: URLRequest) -> ResumableData? {
- guard let url = request.url?.absoluteString else {
- return nil
- }
- return cache.removeValue(forKey: url)
- }
-
- static func storeResumableData(_ data: ResumableData, for request: URLRequest) {
- guard let url = request.url?.absoluteString else {
- return
- }
- cache.set(data, forKey: url, cost: data.data.count)
- }
-}
-
-// MARK: - Atomic
-
-/// A thread-safe value wrapper.
-final class Atomic {
- private var _value: T
- private let lock = NSLock()
-
- init(_ value: T) {
- self._value = value
- }
-
- var value: T {
- get {
- lock.lock()
- let value = _value
- lock.unlock()
- return value
- }
- set {
- lock.lock()
- _value = newValue
- lock.unlock()
- }
- }
-}
-
-extension Atomic where T: Equatable {
- /// "Compare and Swap"
- func swap(to newValue: T, ifEqual oldValue: T) -> Bool {
- lock.lock()
- defer { lock.unlock() }
-
- guard _value == oldValue else {
- return false
- }
- _value = newValue
- return true
- }
-}
-
-extension Atomic where T == Int {
- /// Atomically increments the value and retruns a new incremented value.
- func increment() -> Int {
- lock.lock()
- defer { lock.unlock() }
-
- _value += 1
- return _value
- }
-}
-
-// MARK: - Misc
-
-import CommonCrypto
-
-extension String {
- /// Calculates SHA1 from the given string and returns its hex representation.
- ///
- /// ```swift
- /// print("http://test.com".sha1)
- /// // prints "50334ee0b51600df6397ce93ceed4728c37fee4e"
- /// ```
- var sha1: String? {
- guard let input = self.data(using: .utf8) else {
- return nil
- }
-
- let hash = input.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) -> [UInt8] in
- var hash = [UInt8](repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))
- CC_SHA1(bytes.baseAddress, CC_LONG(input.count), &hash)
- return hash
- }
-
- return hash.map({ String(format: "%02x", $0) }).joined()
- }
-}
-
-// MARK: - Log
-
-final class Log {
- private let log: OSLog
- private let name: StaticString
- private let signpostsEnabled: Bool
-
- init(_ log: OSLog, _ name: StaticString, _ signpostsEnabled: Bool = ImagePipeline.Configuration.isSignpostLoggingEnabled) {
- self.log = log
- self.name = name
- self.signpostsEnabled = signpostsEnabled
- }
-
- // MARK: Signposts
-
- func signpost(_ type: SignpostType, _ message: @autoclosure () -> String) {
- guard signpostsEnabled else { return }
- signpost(type, "%{public}s", message())
- }
-
- func signpost(_ type: SignpostType) {
- guard signpostsEnabled else { return }
- if #available(OSX 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) {
- os_signpost(type.os, log: log, name: name, signpostID: signpostID)
- }
- }
-
- // Unfortunately, there is no way to wrap os_signpost which takes variadic
- // arguments, because Swift implicitly wraps `arguments CVarArg...` from `log`
- // into an array and passes the array to `os_signpost` which is not what
- // we expect. So in this scenario we have to limit the number of arguments
- // to one, there is no way to pass more. For more info see https://stackoverflow.com/questions/50937765/why-does-wrapping-os-log-cause-doubles-to-not-be-logged-correctly
- func signpost(_ type: SignpostType, _ format: StaticString, _ argument: CVarArg) {
- guard signpostsEnabled else { return }
- if #available(OSX 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) {
- os_signpost(type.os, log: log, name: name, signpostID: signpostID, format, argument)
- }
- }
-
- @available(OSX 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *)
- var signpostID: OSSignpostID {
- return OSSignpostID(log: log, object: self)
- }
-}
-
-private let byteFormatter = ByteCountFormatter()
-
-extension Log {
- static func bytes(_ count: Int) -> String {
- return bytes(Int64(count))
- }
-
- static func bytes(_ count: Int64) -> String {
- return byteFormatter.string(fromByteCount: count)
- }
-}
-
-enum SignpostType {
- case begin, event, end
-
- @available(OSX 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *)
- var os: OSSignpostType {
- switch self {
- case .begin: return .begin
- case .event: return .event
- case .end: return .end
- }
- }
-}
diff --git a/Pods/Nuke/Sources/Task.swift b/Pods/Nuke/Sources/Task.swift
deleted file mode 100644
index 3c7a793..0000000
--- a/Pods/Nuke/Sources/Task.swift
+++ /dev/null
@@ -1,302 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2015-2020 Alexander Grebenyuk (github.com/kean).
-
-import Foundation
-
-/// Represents a task with support for multiple observers, cancellation,
-/// progress reporting, dependencies – everything that `ImagePipeline` needs.
-///
-/// A `Task` can have zero or more subscriptions (`TaskSubscription`) which can
-/// be used to later unsubscribe or change the priority of the subscription.
-///
-/// The task has built-in support for operations (`Foundation.Operation`) – it
-/// automatically cancels them, updates the priority, etc. Most steps in the
-/// image pipeline are represented using Operation to take advantage of these features.
-///
-/// - warning: Must be thread-confined!
-final class Task: TaskSubscriptionDelegate {
-
- private struct Subscription {
- let observer: (Event) -> Void
- var priority: TaskPriority
- }
-
- private var subscriptions = [TaskSubscriptionKey: Subscription]()
- private var nextSubscriptionId = 0
-
- /// Returns `true` if the task was either cancelled, or was completed.
- private(set) var isDisposed = false
-
- /// Gets called when the task is either cancelled, or was completed.
- var onDisposed: (() -> Void)?
-
- var onCancelled: (() -> Void)?
-
- private var starter: ((Task) -> Void)?
-
- private var priority: TaskPriority = .normal {
- didSet {
- guard oldValue != priority else { return }
- operation?.queuePriority = priority.queuePriority
- dependency?.setPriority(priority)
- }
- }
-
- /// A task might have a dependency. The task automatically unsubscribes
- /// from the dependency when it gets cancelled, and also updates the
- /// priority of the subscription to the dependency when its own
- /// priority is updated.
- var dependency: TaskSubscription? {
- didSet {
- dependency?.setPriority(priority)
- }
- }
-
- weak var operation: Foundation.Operation? {
- didSet {
- operation?.queuePriority = priority.queuePriority
- }
- }
-
- /// Publishes the results of the task.
- var publisher: Publisher {
- return Publisher(task: self)
- }
-
- /// Initializes the task with the `starter`.
- /// - parameter starter: The closure which gets called as soon as the first
- /// subscription is added to the task. Only gets called once and is immediatelly
- /// deallocated after it is called.
- init(starter: ((Task) -> Void)? = nil) {
- self.starter = starter
- }
-
- // MARK: - Managing Observers
-
- /// - notes: Returns `nil` if the task was disposed.
- fileprivate func subscribe(priority: TaskPriority = .normal, _ observer: @escaping (Event) -> Void) -> TaskSubscription? {
- guard !isDisposed else { return nil }
-
- nextSubscriptionId += 1
- let subscriptionKey = nextSubscriptionId
- let subscription = TaskSubscription(task: self, key: subscriptionKey)
-
- subscriptions[subscriptionKey] = Subscription(observer: observer, priority: priority)
- updatePriority()
-
- starter?(self)
- starter = nil
-
- return subscription
- }
-
- // MARK: - TaskSubscriptionDelegate
-
- fileprivate func setPriority(_ priority: TaskPriority, for key: TaskSubscriptionKey) {
- guard !isDisposed else { return }
-
- subscriptions[key]?.priority = priority
- updatePriority()
- }
-
- fileprivate func unsubsribe(key: TaskSubscriptionKey) {
- guard subscriptions.removeValue(forKey: key) != nil else { return } // Already unsubscribed from this task
- guard !isDisposed else { return }
-
- if subscriptions.isEmpty {
- terminate(reason: .cancelled)
- } else {
- updatePriority()
- }
- }
-
- // MARK: - Sending Events
-
- func send(value: Value, isCompleted: Bool = false) {
- send(event: .value(value, isCompleted: isCompleted))
- }
-
- func send(error: Error) {
- send(event: .error(error))
- }
-
- func send(progress: TaskProgress) {
- send(event: .progress(progress))
- }
-
- private func send(event: Event) {
- guard !isDisposed else { return }
-
- switch event {
- case let .value(_, isCompleted):
- if isCompleted {
- terminate(reason: .finished)
- }
- case .progress:
- break // Simply send the event
- case .error:
- terminate(reason: .finished)
- }
-
- for context in subscriptions.values {
- context.observer(event)
- }
- }
-
- // MARK: - Termination
-
- private enum TerminationReason {
- case finished, cancelled
- }
-
- private func terminate(reason: TerminationReason) {
- guard !isDisposed else { return }
- isDisposed = true
-
- if reason == .cancelled {
- operation?.cancel()
- dependency?.unsubscribe()
- onCancelled?()
- }
- onDisposed?()
- }
-
- // MARK: - Priority
-
- private func updatePriority() {
- priority = subscriptions.values.map({ $0.priority }).max() ?? .normal
- }
-}
-
-// MARK: - Task (Publisher)
-
-extension Task {
- /// Publishes the results of the task.
- struct Publisher {
- let task: Task
-
- /// Attaches the subscriber to the task.
- /// - notes: Returns `nil` if the task is already disposed.
- func subscribe(priority: TaskPriority = .normal, _ observer: @escaping (Event) -> Void) -> TaskSubscription? {
- return task.subscribe(priority: priority, observer)
- }
-
- /// Attaches the subscriber to the task. Automatically forwards progress
- /// andd error events to the given task.
- /// - notes: Returns `nil` if the task is already disposed.
- func subscribe(_ task: Task, onValue: @escaping (Value, Bool, Task) -> Void) -> TaskSubscription? {
- return subscribe { [weak task] event in
- guard let task = task else { return }
- switch event {
- case let .value(value, isCompleted):
- onValue(value, isCompleted, task)
- case let .progress(progress):
- task.send(progress: progress)
- case let .error(error):
- task.send(error: error)
- }
- }
- }
- }
-}
-
-struct TaskProgress: Hashable {
- let completed: Int64
- let total: Int64
-}
-
-typealias TaskPriority = ImageRequest.Priority // typealias will do for now
-
-// MARK: - Task.Event {
-extension Task {
- enum Event {
- case value(Value, isCompleted: Bool)
- case progress(TaskProgress)
- case error(Error)
-
- var isCompleted: Bool {
- switch self {
- case let .value(_, isCompleted): return isCompleted
- case .progress: return false
- case .error: return true
- }
- }
- }
-}
-
-extension Task.Event: Equatable where Value: Equatable, Error: Equatable {}
-
-// MARK: - TaskSubscription
-
-/// Represents a subscription to a task. The observer must retain a strong
-/// reference to a subscription.
-final class TaskSubscription {
- private let task: TaskSubscriptionDelegate
- private let key: TaskSubscriptionKey
-
- fileprivate init(task: TaskSubscriptionDelegate, key: TaskSubscriptionKey) {
- self.task = task
- self.key = key
- }
-
- /// Removes the subscription from the task. The observer won't receive any
- /// more events from the task.
- ///
- /// If there are no more subscriptions attached to the task, the task gets
- /// cancelled along with its dependencies. The cancelled task is
- /// marked as disposed.
- func unsubscribe() {
- task.unsubsribe(key: key)
- }
-
- /// Updates the priority of the subscription. The priority of the task is
- /// calculated as the maximum priority out of all of its subscription. When
- /// the priority of the task is updated, the priority of a dependency also is.
- ///
- /// - note: The priority also automatically gets updated when the subscription
- /// is removed from the task.
- func setPriority(_ priority: TaskPriority) {
- task.setPriority(priority, for: key)
- }
-}
-
-private protocol TaskSubscriptionDelegate: AnyObject {
- func unsubsribe(key: TaskSubscriptionKey)
- func setPriority(_ priority: TaskPriority, for observer: TaskSubscriptionKey)
-}
-
-private typealias TaskSubscriptionKey = Int
-
-// MARK: - TaskPool
-
-/// Contains the tasks which haven't completed yet.
-final class TaskPool {
- private let isDeduplicationEnabled: Bool
- private var map = [AnyHashable: Task]()
-
- init(_ isDeduplicationEnabled: Bool) {
- self.isDeduplicationEnabled = isDeduplicationEnabled
- }
-
- func publisher(withKey key: AnyHashable, starter: @escaping (Task) -> Void) -> Task.Publisher {
- return task(withKey: key) {
- Task(starter: starter)
- }.publisher
- }
-
- private func task(withKey key: AnyHashable, _ make: () -> Task) -> Task {
- guard isDeduplicationEnabled else {
- return make()
- }
- if let task = map[key] {
- return task
- }
- let task = make()
- map[key] = task
- task.onDisposed = { [weak self] in
- self?.map[key] = nil
- }
- return task
- }
-}
diff --git a/Pods/Pods.xcodeproj/project.pbxproj b/Pods/Pods.xcodeproj/project.pbxproj
deleted file mode 100644
index 79205f7..0000000
--- a/Pods/Pods.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,1558 +0,0 @@
-// !$*UTF8*$!
-{
- archiveVersion = 1;
- classes = {
- };
- objectVersion = 51;
- objects = {
-
-/* Begin PBXAggregateTarget section */
- 1CD0618C486973D5588EF20D2E8C0AEA /* SwiftFormat */ = {
- isa = PBXAggregateTarget;
- buildConfigurationList = 6B2B7DF197DF6A7CA487150557230A41 /* Build configuration list for PBXAggregateTarget "SwiftFormat" */;
- buildPhases = (
- );
- dependencies = (
- );
- name = SwiftFormat;
- };
- 52B60EC2A583F24ACBB69C113F5488B9 /* SwiftLint */ = {
- isa = PBXAggregateTarget;
- buildConfigurationList = AE7B4FB01588B9E6DF09CB79FC7CE7BD /* Build configuration list for PBXAggregateTarget "SwiftLint" */;
- buildPhases = (
- );
- dependencies = (
- );
- name = SwiftLint;
- };
-/* End PBXAggregateTarget section */
-
-/* Begin PBXBuildFile section */
- 0265F252A09E5FA6C26381DA4CAF8079 /* CocoaLumberjack-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = F7C3EBDAA592B92C9A8F0B427A82FA7E /* CocoaLumberjack-dummy.m */; };
- 0441B3E976E5F55E22731AECFF0DBA88 /* Keychain.swift in Sources */ = {isa = PBXBuildFile; fileRef = F5AE908EEEB65FAA51B856E87201473A /* Keychain.swift */; };
- 051FAF71CAED233F64E10A1FE97ADEFD /* DDTTYLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = 672DED93DE1741241A5215F8B146CEB9 /* DDTTYLogger.m */; };
- 09944176280C980EB49784DBCA380462 /* ReachabilitySwift-umbrella.h in Headers */ = {isa = PBXBuildFile; fileRef = 279781901E96E13A66D0182F602646D4 /* ReachabilitySwift-umbrella.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 1ACE18FB9618325E6761FC7BB8E35376 /* DDLog.m in Sources */ = {isa = PBXBuildFile; fileRef = 82CCF57044FA0CE7875BA757A99626E9 /* DDLog.m */; };
- 22568D121F150FCFA640B0175197C7C4 /* DDLoggerNames.m in Sources */ = {isa = PBXBuildFile; fileRef = E9A114D8B2B650D8BEA0096CFE9682A2 /* DDLoggerNames.m */; };
- 27586B29124FABF82AAC55429964450A /* DDFileLogger+Buffering.h in Headers */ = {isa = PBXBuildFile; fileRef = 40CDEB4795B2665AE6FC7FB1AFD60149 /* DDFileLogger+Buffering.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 2CC1EEC410C399C6C1B6BAB608B7CE4F /* Internal.swift in Sources */ = {isa = PBXBuildFile; fileRef = 10CD2CC8631ED7864377E255C69B277A /* Internal.swift */; };
- 33CF97469D3F267E887B8320493B195A /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D711FBA503A6418C1F1C8082286D5985 /* Foundation.framework */; };
- 33DA77EE1506C87C374EAC4598286B07 /* Nuke-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 60E3F377CC2CBC7699148A9BDA43812A /* Nuke-dummy.m */; };
- 33E19BC096B66CDE9AF092BE4B1EE4D2 /* DataLoader.swift in Sources */ = {isa = PBXBuildFile; fileRef = 638D98BD06068039ADB89F5621794B92 /* DataLoader.swift */; };
- 353FC14BE702BFB5D9BAD92F7338B3EB /* DDLog+LOGV.h in Headers */ = {isa = PBXBuildFile; fileRef = D62A68690FAD697F3341661EFFB9AF27 /* DDLog+LOGV.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 3DDF693E323B755DC6A79C0AF027FC60 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D711FBA503A6418C1F1C8082286D5985 /* Foundation.framework */; };
- 47DE514FFAFC77339A281C88DC9D26C5 /* ImageCache.swift in Sources */ = {isa = PBXBuildFile; fileRef = EA1BB3B18279C90A477FE088624B4BEC /* ImageCache.swift */; };
- 4AEB48FE18565A59266480250E7C3FEA /* KeychainAccess-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 6DC3FDE23A60AFDD5DBCF6B59E7D67A5 /* KeychainAccess-dummy.m */; };
- 531E8E961587F0E6885690056718AAB4 /* ImagePreheater.swift in Sources */ = {isa = PBXBuildFile; fileRef = E2FA3DD643B5031EBDD9110FF74357BF /* ImagePreheater.swift */; };
- 57B31AE955ABBC6ACA9E7157844E1003 /* ImageTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = CBB646D1CA5BD5E116BB23EDB2CC153F /* ImageTask.swift */; };
- 5857E4CC0AAF89BB24A5DA2EC2CB6481 /* ImageRequest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0160D01D811172F9C5A6C6812F6505 /* ImageRequest.swift */; };
- 5965234C5F96F04527E7FFBEBAF6E191 /* DDTTYLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = E32BCED9A37B6DCC8D6437A69DE8A914 /* DDTTYLogger.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 5D56BA969D6EFFB8F15A0D7EB435C41F /* CocoaLumberjack-umbrella.h in Headers */ = {isa = PBXBuildFile; fileRef = AF68BAC45E5E6A8F1A711F6A51214394 /* CocoaLumberjack-umbrella.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 5DA2B11F9A41C6EAEC8B31F281A6E549 /* ImageViewExtensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 21FC947B68C86DDF8A89F85B4A6360EA /* ImageViewExtensions.swift */; };
- 649A9096456A7DC5E1045E443722991D /* DDLoggerNames.h in Headers */ = {isa = PBXBuildFile; fileRef = 86B65513D2660C87555571A543A55B5C /* DDLoggerNames.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 65B3B0A18B7A1D742BB467F959FB9E41 /* DDFileLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = 7A42C2EB6094E36842F89C11ACB35117 /* DDFileLogger.m */; };
- 66D72D5B6EA704BE40B393A6F0A1B5F6 /* DDAbstractDatabaseLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = 2EF936C70EF390D7C94CC64ED100286C /* DDAbstractDatabaseLogger.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 77451FEEC21F5F4F94A37CE52F87CA58 /* DDContextFilterLogFormatter.m in Sources */ = {isa = PBXBuildFile; fileRef = AB01EFCBAA4E5027700FA9E4035C94B8 /* DDContextFilterLogFormatter.m */; };
- 7916B3022F0E241D986698991C745C16 /* DDContextFilterLogFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = 178D1DA3F1A5AB81DDB34666F43FD8CA /* DDContextFilterLogFormatter.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 7A38D7188792F42AA0B525259BBE3118 /* Task.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D850A921D0BFD951178F049F8D7C5D7 /* Task.swift */; };
- 7BFEE239D45EF5FC4026052A712A2D49 /* DDMultiFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = 939104413F8452D1EBCE06E151383B28 /* DDMultiFormatter.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 7D486A49BC79417C10B6ED59D1F29973 /* DDASLLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = DEC91B6CD94A207E697D195DA8103D62 /* DDASLLogger.m */; };
- 82773CC13612C373B4D313D10D016985 /* CLIColor.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B0114E44979C56CC7953E3298195FCF /* CLIColor.m */; };
- 83EF552F3D8D3E12E3F0F3B7ADD6D3A4 /* DDDispatchQueueLogFormatter.m in Sources */ = {isa = PBXBuildFile; fileRef = 50BB2BB81B4CC785C01757B3313961BA /* DDDispatchQueueLogFormatter.m */; };
- 844BB8D9B204161C40D80A1EDC17F73A /* Nuke-umbrella.h in Headers */ = {isa = PBXBuildFile; fileRef = 357DF0CD03B1EC9DEDCD6B66CAF80E71 /* Nuke-umbrella.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 89A589D04411197399D7FCF7159AAE0A /* CoreTelephony.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F6EE968254130456936592FAD883A845 /* CoreTelephony.framework */; };
- 8A8ECA607EA4E9DDA4A2F1404F1AA4A2 /* ImageDecoding.swift in Sources */ = {isa = PBXBuildFile; fileRef = 025BF06F0871C72DDA9FB73FAD6D566B /* ImageDecoding.swift */; };
- 8F5BD7EB4F1FDF034E047D01B616197D /* CocoaLumberjack.swift in Sources */ = {isa = PBXBuildFile; fileRef = A5DE9C9C9B17E015A5947D4B143132D3 /* CocoaLumberjack.swift */; };
- 9A4D43262635B18C802B17485FAE2D38 /* DDLegacyMacros.h in Headers */ = {isa = PBXBuildFile; fileRef = 15D53DC5981E9D447345E5FCC34E5449 /* DDLegacyMacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 9C7BF137E17C87ACB5EB73DCD9FFECB7 /* Pods-Tote-umbrella.h in Headers */ = {isa = PBXBuildFile; fileRef = 08CC731FA27F62FA77D6D70FF71BE176 /* Pods-Tote-umbrella.h */; settings = {ATTRIBUTES = (Public, ); }; };
- 9D36E15B981166952D88ACDA7EF1FCEF /* ImagePipeline.swift in Sources */ = {isa = PBXBuildFile; fileRef = C2118D38F2AC33A261C242E0168A3A74 /* ImagePipeline.swift */; };
- 9EC4DC3F4A764364051BE6DB7FD72161 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D711FBA503A6418C1F1C8082286D5985 /* Foundation.framework */; };
- A198E44609AC439B57F319EBA10C42DA /* ImageProcessing.swift in Sources */ = {isa = PBXBuildFile; fileRef = 498B498347CCE1DBE5FA997184ED1B75 /* ImageProcessing.swift */; };
- A1AE5A3B4287E91E5716E4969D7E9500 /* Pods-Tote-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 9DDC1EC44E728131DF2DA1D1A7DECEAB /* Pods-Tote-dummy.m */; };
- A3DD30BA881E3D94258F0887BCF4944B /* DDFileLogger+Buffering.m in Sources */ = {isa = PBXBuildFile; fileRef = 90A7242AD9B5CD6DE7DE4C5E170BAC92 /* DDFileLogger+Buffering.m */; };
- A907EF76A9D5FF8E392290B10E97ED69 /* DDDispatchQueueLogFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = 54EA2C94A5E61570C043BE7E807221B9 /* DDDispatchQueueLogFormatter.h */; settings = {ATTRIBUTES = (Public, ); }; };
- AAC9ECA67A80A03C3761E73F34F043A3 /* DDASLLogCapture.m in Sources */ = {isa = PBXBuildFile; fileRef = F0505009C253467EBEDE8252BBFEB7F5 /* DDASLLogCapture.m */; };
- AB1778BEF12E281DCA6520DB182C0A30 /* ImagePipelineConfiguration.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8FCF0BA549E7B534F676D7F88D6602C1 /* ImagePipelineConfiguration.swift */; };
- AC96F44279E61358242F26840D4853F0 /* Reachability.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2DE766B46B2FEE03D20B9632D7F50ADA /* Reachability.swift */; };
- B8FFCC85726A84D09376205AB404513D /* DDLog.h in Headers */ = {isa = PBXBuildFile; fileRef = A148A893AB0A4E50C35E9F9963CE0442 /* DDLog.h */; settings = {ATTRIBUTES = (Public, ); }; };
- B99DB958F2C7DA6223C0D2CABE7299AD /* DDOSLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = A2BDDEF321BAA79C985363F797976F5B /* DDOSLogger.m */; };
- BA873BE7155FCC56E178360D4E54992B /* DDAbstractDatabaseLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = F8344A501C64A09EB65FD758AD8BFDFB /* DDAbstractDatabaseLogger.m */; };
- C2B4C43E316156C7BAA89EF72C3BC209 /* ImageEncoding.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8AFAAEA84C328F8D59F0BE1F993D9C0B /* ImageEncoding.swift */; };
- C4E060E3D1AB869610D1ACBA2AD852FD /* DDASLLogCapture.h in Headers */ = {isa = PBXBuildFile; fileRef = C57118EB7AA33C8194D4F00EFAFC9818 /* DDASLLogCapture.h */; settings = {ATTRIBUTES = (Public, ); }; };
- CA98B616E393378017EB03F4997E9476 /* DDOSLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = 4D02AD857D0724F6D3F3B29D3B884BBD /* DDOSLogger.h */; settings = {ATTRIBUTES = (Public, ); }; };
- DA2DD0CB6F0E3CC436D18CF167DA4484 /* DDLogMacros.h in Headers */ = {isa = PBXBuildFile; fileRef = 672D9F969296C029F71F1219982AB3D0 /* DDLogMacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
- DCB4BC4CB3BFC32F3A975995BEB6F92B /* DDMultiFormatter.m in Sources */ = {isa = PBXBuildFile; fileRef = 9818ACA6A0B5A8A1CE4D6689027D6AF0 /* DDMultiFormatter.m */; };
- E113BFF705F231576AB1BC02E8CD31FF /* Deprecated.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB6DC42C1112DD7D6D641BA7636C1DCC /* Deprecated.swift */; };
- E28271382E0061543ADBF1D1A026692D /* DDASLLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = F4CD23C55C9ADDDF26D16C966E6B8148 /* DDASLLogger.h */; settings = {ATTRIBUTES = (Public, ); }; };
- E3AEEA91A67D0F8E24F52FE562ABF1B6 /* DDFileLogger+Internal.h in Headers */ = {isa = PBXBuildFile; fileRef = C61B806FBF4B7DD81787E5B471559749 /* DDFileLogger+Internal.h */; settings = {ATTRIBUTES = (Private, ); }; };
- E5938189529B1F8BD074BB166C8BDE57 /* SystemConfiguration.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F64256263F0F1E673BCBD67DF6958420 /* SystemConfiguration.framework */; };
- E5F6ACACDF29D937A21E7DEC85A13E3E /* ReachabilitySwift-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 588241B4D58700A371528D8299906711 /* ReachabilitySwift-dummy.m */; };
- E9E9554C02CA5FC8F7F134D4BA53B6C6 /* DDAssertMacros.h in Headers */ = {isa = PBXBuildFile; fileRef = C0345E727B14B21D4F19E0FEBC358B9D /* DDAssertMacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
- EA6CE99F0BF16FF0CCD17E1ED26F253F /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D711FBA503A6418C1F1C8082286D5985 /* Foundation.framework */; };
- EBD52493DDF31B7F9F1F731195214D80 /* SwiftLogLevel.h in Headers */ = {isa = PBXBuildFile; fileRef = 23583B809B813AF971FD9EAC8E4A566A /* SwiftLogLevel.h */; settings = {ATTRIBUTES = (Public, ); }; };
- ECCD7732CF0D16FCC90DB83E75D73495 /* DDFileLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BE1E92F34DA506D215058D48DAFC34E /* DDFileLogger.h */; settings = {ATTRIBUTES = (Public, ); }; };
- EEADFC5C1C5EC6E3E20506B8E069931D /* KeychainAccess-umbrella.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A6E9469E45730BBC97C073A0052F03 /* KeychainAccess-umbrella.h */; settings = {ATTRIBUTES = (Public, ); }; };
- EFFCEE76EDA4E17534AA3E8D48523439 /* CocoaLumberjack.h in Headers */ = {isa = PBXBuildFile; fileRef = C7CBFC6087DC2EF28F1F3E8A5AA98107 /* CocoaLumberjack.h */; settings = {ATTRIBUTES = (Public, ); }; };
- F09ACB2C5062701272570EBBE36BB7C7 /* DataCache.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5B2093BE89130E50C4AF4C5BAF24E2A9 /* DataCache.swift */; };
- F6949BF2A8CF492225A02F703377EA0D /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D711FBA503A6418C1F1C8082286D5985 /* Foundation.framework */; };
- F7A1CB7A1DAC0FFC21CE547FFC3F09C6 /* DDAssert.swift in Sources */ = {isa = PBXBuildFile; fileRef = 377204AF0F04F5F5E6324F481313B3A2 /* DDAssert.swift */; };
- FCFA53A0A359E33E514B981BB7AF7771 /* CLIColor.h in Headers */ = {isa = PBXBuildFile; fileRef = D3A8AF767BFE359C9C7D8F4BF82F4DE1 /* CLIColor.h */; settings = {ATTRIBUTES = (Public, ); }; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
- 2DA982F00E29CE1FEEEB33624867354B /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = E95654B155D25890BE8E26081FCA8265;
- remoteInfo = CocoaLumberjack;
- };
- 804DF6BA694C52C326F4FA63B230EA7A /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = 52B60EC2A583F24ACBB69C113F5488B9;
- remoteInfo = SwiftLint;
- };
- ABB4508EE29C3251B34417F309063D0A /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = 0B00B2C167CD783351BD1D00BD5AD1F8;
- remoteInfo = ReachabilitySwift;
- };
- C5D3508298216988BBE43C3AAB9ADFF6 /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = 1CD0618C486973D5588EF20D2E8C0AEA;
- remoteInfo = SwiftFormat;
- };
- E3BC3FB11F80CBD306F0CE7FFFE05840 /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = 615C831BCE925ED486B225B87E44926D;
- remoteInfo = KeychainAccess;
- };
- E6A610F4AA3D3BA440278CDF6AD345D2 /* PBXContainerItemProxy */ = {
- isa = PBXContainerItemProxy;
- containerPortal = BFDFE7DC352907FC980B868725387E98 /* Project object */;
- proxyType = 1;
- remoteGlobalIDString = 062A64896E847A6749F58B6BA9A931B1;
- remoteInfo = Nuke;
- };
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
- 025BF06F0871C72DDA9FB73FAD6D566B /* ImageDecoding.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = ImageDecoding.swift; path = Sources/ImageDecoding.swift; sourceTree = ""; };
- 038E03835AD4F2058241E0822184B8EC /* CocoaLumberjack-prefix.pch */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; path = "CocoaLumberjack-prefix.pch"; sourceTree = ""; };
- 06AE309C2EE3F09A2119E06F4E85FE0D /* Pods-Tote-Info.plist */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.plist.xml; path = "Pods-Tote-Info.plist"; sourceTree = ""; };
- 08CC731FA27F62FA77D6D70FF71BE176 /* Pods-Tote-umbrella.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; path = "Pods-Tote-umbrella.h"; sourceTree = ""; };
- 10CD2CC8631ED7864377E255C69B277A /* Internal.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = Internal.swift; path = Sources/Internal.swift; sourceTree = ""; };
- 15D53DC5981E9D447345E5FCC34E5449 /* DDLegacyMacros.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = DDLegacyMacros.h; path = "Sources/CocoaLumberjack/Supporting Files/DDLegacyMacros.h"; sourceTree = ""; };
- 178D1DA3F1A5AB81DDB34666F43FD8CA /* DDContextFilterLogFormatter.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = DDContextFilterLogFormatter.h; path = Sources/CocoaLumberjack/include/DDContextFilterLogFormatter.h; sourceTree = ""; };
- 178FF0CFFE3C271772B4FAE638474506 /* CocoaLumberjack.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; path = CocoaLumberjack.release.xcconfig; sourceTree = ""; };
- 1A0160D01D811172F9C5A6C6812F6505 /* ImageRequest.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = ImageRequest.swift; path = Sources/ImageRequest.swift; sourceTree = ""; };
- 21B03CA622E690725A6626C088E1D09F /* Reachability.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; name = Reachability.framework; path = ReachabilitySwift.framework; sourceTree = BUILT_PRODUCTS_DIR; };
- 21FC947B68C86DDF8A89F85B4A6360EA /* ImageViewExtensions.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = ImageViewExtensions.swift; path = Sources/ImageViewExtensions.swift; sourceTree = ""; };
- 23583B809B813AF971FD9EAC8E4A566A /* SwiftLogLevel.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = SwiftLogLevel.h; path = Sources/CocoaLumberjackSwiftSupport/include/SwiftLogLevel.h; sourceTree = "
-
-