Cached Image

• Same API shape as AsyncImage: url, optional scale, content and placeholder closures
• Memory cache of decoded CGImages in an NSCache priced by byte size (200 MB default, purged by the system under memory pressure)
• Synchronous lookup while the view is built: a cached image never shows the placeholder, even for one frame
• Dedicated disk cache (URLCache in Caches/SWImageCache, 200 MB) with .returnCacheDataElseLoad: cached images load offline and never revalidate
• One request per URL at a time, shared by every view that asks for it
• 404 / 410 remembered for the session; network errors are not, so the next appearance retries
• Background decoding through ImageIO, with EXIF orientation applied and the longest side capped at 2400 px
• Cross-platform: renders through Image(decorative:scale:), so the same file builds for iOS and macOS
• ImageRenderer can draw a cached remote image (share cards, receipts), where AsyncImage only ever renders its placeholder

// 1. Avatar with a monogram fallback (no URL, loading, or failed)
SWCachedImage(url: user.avatarURL) { image in
    image.resizable().scaledToFill()
} placeholder: {
    Circle()
        .fill(.blue.opacity(0.15))
        .overlay { Text(user.initial).font(.headline) }
}
.frame(width: 40, height: 40)
.clipShape(Circle())

// 2. Feed photo inside a fixed frame (overlay keeps scaledToFill from widening the layout)
Color.clear
    .frame(height: 220)
    .overlay {
        SWCachedImage(url: post.photoURL) { image in
            image.resizable().scaledToFill()
        } placeholder: {
            Color.secondary.opacity(0.15)
        }
    }
    .clipShape(RoundedRectangle(cornerRadius: 16, style: .continuous))

// 3. Lists: give rows a stable id so they are not rebuilt on every render
ForEach(people, id: \.userID) { person in
    SWCachedImage(url: person.avatarURL) { $0.resizable().scaledToFill() } placeholder: { Color.gray }
        .frame(width: 32, height: 32)
        .clipShape(Circle())
}

// 4. Warm the cache as soon as data arrives, so the first appearance skips the placeholder too
for url in snapshot.avatarURLs {
    Task { _ = await SWImageCache.shared.image(for: url) }
}

• Drop SWCachedImage.swift into the project and replace every AsyncImage that shows a remote image
• Make image URLs immutable: a new upload gets a new key (for example a UUID file name). If your backend overwrites files in place, append a version to the URL (?v=updatedAt), otherwise the disk cache keeps serving the old image
• Have the image server send Cache-Control: public, max-age=31536000, immutable, so other clients and CDNs cache it as well
• macOS sandboxed apps need the Outgoing Connections (Client) entitlement
• Tune memoryLimit, diskLimit and maxPixelSize in SWImageCache.init if your images are much larger or smaller than typical photos

• Unstable ids rebuild views: a view model built in a computed property with let id = UUID() gets new ids on every render, so ForEach tears down and re-creates its rows (local @State resets, AsyncImage restarts). The cache hides the flash, but use a stable business key (user id, name, record id) as the id anyway
• Do not load images through URLSession.shared: its shared URLCache is small and shared with every API GET in the app. Images get their own session and cache directory here
• Decode off the main thread: UIImage(data:) decodes lazily on the main thread during the first draw, which drops frames for large photos. Here ImageIO decodes inside Task.detached
• nonisolated is not "background": with default MainActor isolation and approachable concurrency (NonisolatedNonsendingByDefault), a nonisolated async helper runs on the caller's executor, which is the main thread. That is why the decode step is a detached task
• First load still shows the placeholder until the bytes arrive from the network or are read back from disk (tens of milliseconds, longer when a cold launch reads many at once). Warm the cache with SWImageCache.shared.image(for:) when the data arrives if the first appearance matters
• Memory budget: a 1600 × 1600 photo is about 10 MB decoded. Images on screen stay alive through the view's state even after eviction; lower maxPixelSize for thumbnail-only screens