I have the following code:

LazyImage(source: model.fileUrl)
                        .processors([ImageProcessors.Resize(width: 800)])
                        .transition(.fadeIn(duration: 0.15))
                        .aspectRatio(1, contentMode: .fit)
                        .background(Color(.controlColor))

The image appears, however its not filling/scaling up as I'd expect to fill the container. It appears to have a fixed size, cantering inside of the container? The background therefore shows around the edges. Is this currently unsupported?

FYI, I've reverted for the moment to the old FetchImage implementation directly and that works fine, but would be great to use this new type as I think its far better from an API POV 👍

Great work by the way, my favourite image library in over a decade!

I'm having an issue where some images do not load. I've found that when loading a very large number of items in a vertical scrolling list, some of the images do not load; although, they do start. I've tried checking errors with the .onFailure, and setting up the onProgress handler to check if they are downloading, but they're not. I only see the Color that I've set in the final else statement inside of the LazyImage init closure.

You'll notice that the images load if I slightly scroll. It's as though they've downloaded, but something is blocking the UI thread from refreshing.

Xcode and iOS beta 3.

Here is the code:

LazyImage(source: imageUrl) { state in
                    if let image = state.image {
                        image
                            .clipped(antialiased: true)
                            .clipShape(RoundedRectangle(cornerRadius: 10))
                    } else if state.error != nil {
                        Color.red // Indicates an error
                    } else {
                        Color
                            .gray
                            .cornerRadius(10)
                            .opacity(0.2)
                    }
                }
                .onSuccess { response in
                    debugPrint("image success")
                }
                .onStart{ task in
                    debugPrint("Started: \(task.request.url!)")
                }
                .onFailure{ error in
                    debugPrint("Failure: \(error)")
                }
                .onProgress{ response, completed, total in
                    debugPrint("Progress: \(total)")
                }
                .frame(minHeight: mediaHeight, maxHeight: mediaHeight, alignment: .center)

How does one implement disk caching with LazyImage?

https://user-images.githubusercontent.com/553800/125739868-1d31370b-9fb5-4eef-a735-7bcf900dc0cc.mp4

This PR improves work with video.

• extends ImageContainer with asset: AVAsset?. I think it can be moved to main Nuke framework. This allows playing videos with custom Views, e.g. SwiftUI.VideoPlayer from iOS 14.
• improves VideoPlayer view API. I think in future it should mimic SwiftUI.VideoPlayer from iOS 14.

Hi Alexander,

we are seeing a strange Crash on iOS 14.3 when onDisappear is called in LazyImage. It fails in FetchImage:208 if isLoading { isLoading = false } with Fatal error: Attempted to read an unowned reference but the object was already deallocated.

I guess it is some kind of SwiftUI bug. We are seeing it in newer iOS 14 Versions as well, but it happens a lot in 14.3.

By accident I found out, that we can prevent the crash, if we don't reset or cancel the model, but just lower the requests priority. I know it makes no sense from a performance perspective, but at least our app doesn't crash that way 😅

Best regards Peter

Hi,

I'm using 2 types of images (one for compact, one for regular) and i'm switching images after a device rotation or window resize.

But the good image is loaded only the first time, after a device rotation, the result are "inversed", ie: seeing portrait image in landscape and landscape image in portrait.

You can test with this code on an iPhone and rotate the device:

import SwiftUI
import NukeUI


struct TestView: View {
    
    @Environment(\.horizontalSizeClass) var wSizeClass
    @Environment(\.verticalSizeClass) var hSizeClass
    
    var body: some View {
        VStack {
            Text("LazyImage").foregroundColor(.white)
            LazyImage(source: hSizeClass == .regular ? "https://liquidchaostattoos.com/wp-content/uploads/2015/06/artist-portrait-placeholder.jpg" : "https://www.ctsfw.edu/wp-content/uploads/2016/02/landscape-placeholder-image.jpg")
                .frame(width: 150, height: 150)
            
            
            Text("AsyncImage").foregroundColor(.white)
            if #available(iOS 15.0, *) {
                AsyncImage(url: hSizeClass == .regular ?
                           URL(string: "https://liquidchaostattoos.com/wp-content/uploads/2015/06/artist-portrait-placeholder.jpg")! :
                            URL(string: "https://www.ctsfw.edu/wp-content/uploads/2016/02/landscape-placeholder-image.jpg")!) { image in
                    image.resizable()
                } placeholder: {
                    ProgressView()
                }
                .frame(width: 150, height: 150)
            } else {
                // Fallback on earlier versions
            }
        }
    }
}

struct TestView_Previews: PreviewProvider {
    static var previews: some View {
        NavigationView {
            TestView()
                .environment(\.colorScheme, .dark)
        }
    }
}

Essentially we can't upgrade to Nuke 10 until we can remove FetchImage.

You can mark this as closed if its something you just don't want to do but I imagine there will be holdouts until people can drop support for iOS 13.

I'm trying to use LazyImage inside List, by giving it an aspect ratio like this:

struct ContentView: View {
    var data = (1...50).map { $0 }
    var ratios: [CGFloat] = [16/9, 21/3, 1]
    
    var aspectRatio: CGFloat {
        ratios.randomElement()!
    }
    
    var body: some View {
        NavigationView {
            List {
                ForEach(data, id: \.self) { model in
                    LazyImage(source: "https://picsum.photos/300/300")
                        .aspectRatio(aspectRatio, contentMode: .fill)
                        .padding(.horizontal)
                        .padding(.bottom)
                }
                .listRowSeparator(.hidden)
                .listRowBackground(Color.clear)
                .listRowInsets(.init(top: 0, leading: 0, bottom: 0, trailing: 0))
            }
            .listStyle(.plain)
            
        }
    }
}

The problem is that the elements get overlapped when you scroll, like this:

This doesn't reproduce if i use ScrollView, only with List

I am building an app that has an internal private Swift Package where I do most of my work shared across multiple targets

One of those targets is a macOS Catalyst app

My SPM product contains NukeUI as one of the target dependencies, however there are build errors since macOS Catalyst seems to build as an iOS app under a macOS environment? I'm new to it so I am not sure what's happening, but this is the list of errors I get, which is odd since they are inside a #if os(iOS) || os(tvOS)

Just to note, building the target using any iOS device works, but when I change the scheme to macOS, it fails

It would be nice if this package implemented the same features, such as the caching and gif support, using the new, OOB, AsyncImage in SwiftUI. Perhaps using phases?

This is really great, thx for this!

Can you tag this and lock the Nuke version in the package manager to 10.0.0? Because I use other dependencies, like GetStream, that also uses Nuke as a dependency so the versions need to line up.

Hi,

I'm trying to add the package to my Xcode project but getting the error "Failed to resolve dependencies".

Clicking "Add Anyway" adds the package, but it fails to resolve and causes the project to fail to build (copying components from another project that already use this).

Is there something special I need to do?

Thanks

Hello,

First off - thanks for the effort on the library - really appreciate it!

In my project I'm using NukeUI and Introspect I have a view that uses about 10 LazyImages to download and show an mp4 and another piece of that view that responds to a sheet modifier that utilizes detents on iOS 15 via Introspect, as they're not yet in SwiftUI.

The issue that I'm seeing is that if I show that view via a NavigationView more than 3 times, the mp4s no longer load and play.

Additionally, inspecting the memory graph, shows that even if I navigate away from that view, there are about 60 LazyImage and VideoPlayerView sticking around in memory, which I assume is the crux of the issue.

Commenting out the Introspect portion fixes the issue and everything works as expected, but I need it in my app for other things as well.

Now, this might very well be an Introspect issue and I'm raising an issue in that repo as well, but just wanted to see whether the maintainer here might have any insights into why this is happening.

Code that reproduces the issue

Tested on iOS 15.4.1 on iPhone 12 Pro Max, compiled with Xcode 13.3.1 (interestingly the simulator doesn't show the issue)

NukeUI version: 0.8.1 Introspect version: 0.1.4

Video of the issue:

https://user-images.githubusercontent.com/82413230/168490919-ee292d87-d8ed-4939-b278-138c6648d7e3.mov

Memory graph:

Thanks!

Is it possible to not set const image height if it's cached and loaded from the memory or when it's loaded? So, I want to show a placeholder for the very first load and then allow an image to fill all width provided by a container and let an image preserve its aspect ratio for height.

While loading a list of images, sometimes, randomly, the image does not load. If you restart, after few times, it works.

Console logs: Task <72B7A449-92F7-41E1-AB00-5A2D634E541B>.<9> finished with error [303] Error Domain=kCFErrorDomainCFNetwork Code=303 "(null)" UserInfo={_NSURLErrorFailingURLSessionTaskErrorKey=LocalDataTask <72B7A449-92F7-41E1-AB00-5A2D634E541B>.<9>, _kCFStreamErrorDomainKey=4, NSErrorPeerAddressKey=<CFData 0x60000086caf0 [0x1da82daf0]>{length = 16, capacity = 16, bytes = 0x100201bbd15e5a010000000000000000}, _kCFStreamErrorCodeKey=-2201, _NSURLErrorRelatedURLSessionTaskErrorKey=( "LocalDataTask <72B7A449-92F7-41E1-AB00-5A2D634E541B>.<9>" )}

Used with: LazyImage(source: imageUrl, resizingMode: .aspectFit) .frame(maxWidth: .infinity, maxHeight: .infinity) .aspectRatio(contentMode: .fit)

Any idea?

Is it possible to read in the pixel data of the image as a UIImage or NSImage to be used with a plugin that can get the common color of the image so set it as a backdrop / background color?

As a bonus it would be fantastic if this receiving a background color of the image as built into NukeUI.

Hello there,

First of all, let me start by saying, thank you for creating such a great package. It has greatly simplified our image loading and caching, something that we wish Apple offered out of the box.

When running the app on an iOS 15 device, we have discovered that even if the image has already been loaded, our placeholder view will always be shown before displaying the cached image. When the view reappears, the placeholder will be shown for a brief moment before the cached image is loaded in. This creates the effect that the image is being loaded again, however I have confirmed that there is no network activity. It appears to be something to do with the fact that the image has an animation added to it.

Example code:

LazyImage(source: url) { state in
    if let image = state.image {
        image
            .aspectRatio(contentMode: .fit)
    } else {
        generic
            .aspectRatio(contentMode: .fit)
    }
}
.frame(height: targetHeight)
.animation(.easeIn)
.clipShape(Circle()))

Putting a breakpoint in the content closure shows that it is initially called with a nil value for state.image, before almost immediately being called again with a non-nil image. This results in the behaviour I described above.

When removing the animation, it works as expected. The above code works fine running on iOS 14, using the same build. We are building using Xcode 12.5.1, and I have also confirmed that this issue is present when building using Xcode 13.

I suspect that this may be something to do with changes to the way SwiftUI handles animations, but I thought I'd point it out here nonetheless in case it is something you need to look into.