### Install URLImage using Swift Package Manager

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Add the URLImage package to your Xcode project via the Swift Packages menu. Ensure you use the correct repository URL.

```bash
https://github.com/dmytro-anokhin/url-image
```

--------------------------------

### Control URLImage Loading with Options

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Customize when URLImage starts and stops loading by applying load options. Useful for optimizing performance in lists.

```swift
List(/* ... */) {
    // ...
}
    .environment(\.urlImageOptions, URLImageOptions(loadOptions: [ .loadOnAppear, .cancelOnDisappear ]))

```

--------------------------------

### Configure URLImage with Custom File Store

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Set up URLImageService with a custom file store and in-memory store for advanced caching. This configuration is necessary when you want to manage caching explicitly, for example, for offline image access.

```swift
import URLImage
import URLImageStore

@main
struct MyApp: App {

    var body: some Scene {

        let urlImageService = URLImageService(fileStore: URLImageFileStore(),
                                          inMemoryStore: URLImageInMemoryStore())

        return WindowGroup {
            FeedListView()
                .environment(\.urlImageService, urlImageService)
        }
    }
}
```

--------------------------------

### Configuring URLImage Options with Environment

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Control download aspects like max pixel size using URLImageOptions set via the environment. This can be applied to specific views or the entire app.

```swift
URLImage(url) { image in
    image
        .resizable()
        .aspectRatio(contentMode: .fit)
}
.environment(\.urlImageOptions, URLImageOptions(
    maxPixelSize: CGSize(width: 600.0, height: 600.0)
))
```

```swift
@main
struct MyApp: App {

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.urlImageOptions, URLImageOptions(
                    maxPixelSize: CGSize(width: 600.0, height: 600.0)
                ))
        }
    }
}
```

--------------------------------

### Create a Custom URLImage View

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Build a reusable custom image view by encapsulating RemoteImage logic. Load the image manually when the view appears.

```swift
struct MyURLImage: View {

    @ObservedObject private var remoteImage: RemoteImage

    init(service: URLImageService, url: URL) {
        remoteImage = service.makeRemoteImage(url: url, identifier: nil, options: URLImageOptions())
    }

    var body: some View {
        ZStack {
            switch remoteImage.loadingState {
                case .success(let value):
                    value.image

                default:
                    EmptyView()
            }
        }
        .onAppear {
            remoteImage.load()
        }
    }
}

```

--------------------------------

### Basic URLImage Usage

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Create a URLImage view by providing a URL and a SwiftUI ViewBuilder for the image content. Ensure the URL is of type URL, not String.

```swift
import URLImage // Import the package module

let url: URL = //...

URLImage(url) { image in
    image
        .resizable()
        .aspectRatio(contentMode: .fit)
}
```

--------------------------------

### Configure URLImageService with InMemoryStore

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Set up URLImageService with an in-memory store to prevent image resets when views reload, especially when used with controls like TextField. This should be configured at the app's entry point.

```swift
import SwiftUI
import URLImage
import URLImageStore

@main
struct MyApp: App {
    var body: some Scene {
        let urlImageService = URLImageService(fileStore: nil, inMemoryStore: URLImageInMemoryStore())

        return WindowGroup {
            ContentView()
                .environment(\.urlImageService, urlImageService)
        }
    }
}
```

--------------------------------

### Basic URLImage Usage

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Display an image from a URL with basic resizing. This is the simplest way to integrate URLImage into your SwiftUI view.

```swift
URLImage(url: url) {
    image
        .resizable()
        .aspectRatio(contentMode: .fit)
}
```

--------------------------------

### Fetch Multiple Images as CGImage Array

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Download multiple images concurrently using RemoteImagePublisher, convert them to CGImage, and collect the results into an array. Errors are handled by returning nil for individual images.

```swift
let publishers = urls.map { URLImageService.shared.remoteImagePublisher($0) }

cancellable = Publishers.MergeMany(publishers)
    .tryMap { $0.cgImage }
    .catch { _ in
        Just(nil)
    }
    .collect()
    .sink { images in
        // images is [CGImage?]
    }

```

--------------------------------

### Fetch Image as CGImage with Error Handling

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Download an image using RemoteImagePublisher and convert it to CGImage, ignoring any errors during the process. The result is cached by default.

```swift
cancellable = URLImageService.shared.remoteImagePublisher(url)
    .tryMap { $0.cgImage }
    .catch { _ in
        Just(nil)
    }
    .sink { image in
        // image is CGImage or nil
    }

```

--------------------------------

### Set Rendering Mode for Navigation/Toolbar Images

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

When an image in a navigation or toolbar appears as a single color rectangle, apply `.renderingMode(.original)` to the URLImage to ensure it displays correctly.

```swift
URLImage(url) { image in
    image.renderingMode(.original)
}
```

--------------------------------

### Integrating with AdvancedScrollView for Zoom

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Combine URLImage with AdvancedScrollView to enable image scaling and zooming functionality. Ensure both packages are imported.

```swift
import AdvancedScrollView
import URLImage

URLImage(url) { image in
    AdvancedScrollView(magnificationRange: 1.0...4.0) { _ in
        image
    }
}
```

--------------------------------

### Accessing Image Information

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Utilize the ImageInfo argument in the content closure to access details like the image's actual size, enabling conditional display logic.

```swift
URLImage(item.imageURL) { image, info in
    if info.size.width < 1024.0 {
        image
            .resizable()
            .aspectRatio(contentMode: .fit)
    } else {
        image
            .resizable()
            .aspectRatio(contentMode: .fill)
    }
}
```

--------------------------------

### Customizing URLImage States

Source: https://github.com/dmytro-anokhin/url-image/blob/main/README.md

Customize the appearance for empty, in-progress, failure, and content states using ViewBuilder arguments. The failure state provides a retry action.

```swift
URLImage(item.imageURL) { // This view is displayed before download starts
    EmptyView()
} inProgress: { progress in
    // Display progress
    Text("Loading...")
} failure: { error, retry in
    // Display error and retry button
    VStack {
        Text(error.localizedDescription)
        Button("Retry", action: retry)
    }
} content: { image in
    // Downloaded image
    image
        .resizable()
        .aspectRatio(contentMode: .fit)
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.