Update view when document changes

Author: gonzalezreal

Package.swift

@@ -41,6 +41,7 @@ let package = Package(
             url: "https://github.com/gonzalezreal/NetworkImage",
             from: "2.1.0"
         ),
+        .package(url: "https://github.com/pointfreeco/combine-schedulers", from: "0.1.2"),
         .package(
             name: "SnapshotTesting",
             url: "https://github.com/pointfreeco/swift-snapshot-testing",
@@ -66,6 +67,7 @@ let package = Package(
                 "CommonMark",
                 "AttributedText",
                 "NetworkImage",
+                .product(name: "CombineSchedulers", package: "combine-schedulers"),
             ]
         ),
         .testTarget(

Sources/MarkdownUI/Shared/ImageDownloader+TextAttachments.swift

@@ -1,4 +1,4 @@
-#if canImport(SwiftUI) && !os(watchOS) && !targetEnvironment(macCatalyst)
+#if canImport(SwiftUI) && !os(watchOS)
 
     import SwiftUI
 
@@ -11,7 +11,7 @@
 
         /// Sets the markdown style in this view and its children.
         @available(macOS 11.0, *)
-        func markdownStyle(_ markdownStyle: @autoclosure @escaping () -> MarkdownStyle) -> some View {
+        func markdownStyle(_ markdownStyle: MarkdownStyle) -> some View {
             environment(\.markdownStyle, markdownStyle)
         }
     }
@@ -24,7 +24,7 @@
         }
 
         @available(macOS 11.0, *)
-        var markdownStyle: () -> MarkdownStyle {
+        var markdownStyle: MarkdownStyle {
             get { self[MarkdownStyleKey.self] }
             set { self[MarkdownStyleKey.self] = newValue }
         }
@@ -37,9 +37,7 @@
 
     @available(macOS 11.0, iOS 13.0, tvOS 13.0, *)
     private struct MarkdownStyleKey: EnvironmentKey {
-        static let defaultValue: () -> MarkdownStyle = {
-            MarkdownStyle(font: .system(.body))
-        }
+        static let defaultValue = MarkdownStyle(font: .system(.body))
     }
 
 #endif

Sources/MarkdownUI/Shared/Markdown+Environment.swift

@@ -44,9 +44,7 @@
         @Environment(\.multilineTextAlignment) private var multilineTextAlignment: TextAlignment
         @Environment(\.sizeCategory) private var sizeCategory: ContentSizeCategory
         @Environment(\.markdownBaseURL) private var markdownBaseURL: URL?
-        @Environment(\.markdownStyle) private var markdownStyle: () -> MarkdownStyle
-
-        @StateObject private var store = MarkdownStore()
+        @Environment(\.markdownStyle) private var markdownStyle: MarkdownStyle
 
         private let document: Document
 
@@ -57,21 +55,78 @@
         }
 
         public var body: some View {
-            AttributedText(store.attributedText)
-                .onChange(of: sizeCategory) { _ in
-                    store.onStyleChange(markdownStyle())
-                }
-                .onAppear {
-                    store.onAppear(
-                        document: document,
-                        environment: MarkdownStore.Environment(
-                            layoutDirection: layoutDirection,
-                            multilineTextAlignment: multilineTextAlignment,
-                            baseURL: markdownBaseURL,
-                            style: markdownStyle()
-                        )
-                    )
-                }
+            PrimitiveMarkdown(
+                document: document,
+                baseURL: markdownBaseURL,
+                writingDirection: NSWritingDirection(layoutDirection: layoutDirection),
+                alignment: NSTextAlignment(
+                    layoutDirection: layoutDirection,
+                    multilineTextAlignment: multilineTextAlignment
+                ),
+                style: markdownStyle,
+                isSynchronous: false
+            )
+        }
+    }
+
+    @available(macOS 11.0, iOS 14.0, tvOS 14.0, *)
+    private struct PrimitiveMarkdown: View {
+        @ObservedObject private var renderer: MarkdownRenderer
+
+        init(
+            document: Document,
+            baseURL: URL?,
+            writingDirection: NSWritingDirection,
+            alignment: NSTextAlignment,
+            style: MarkdownStyle,
+            isSynchronous: Bool
+        ) {
+            renderer = MarkdownRenderer(
+                document: document,
+                baseURL: baseURL,
+                writingDirection: writingDirection,
+                alignment: alignment,
+                style: style,
+                environment: isSynchronous ? .synchronous : .default
+            )
+        }
+
+        var body: some View {
+            AttributedText(renderer.attributedString)
+        }
+    }
+
+    private extension NSWritingDirection {
+        @available(macOS 10.15, iOS 13.0, tvOS 13.0, *)
+        init(layoutDirection: LayoutDirection) {
+            switch layoutDirection {
+            case .leftToRight:
+                self = .leftToRight
+            case .rightToLeft:
+                self = .rightToLeft
+            @unknown default:
+                self = .natural
+            }
+        }
+    }
+
+    private extension NSTextAlignment {
+        @available(macOS 10.15, iOS 13.0, tvOS 13.0, *)
+        init(layoutDirection: LayoutDirection, multilineTextAlignment: TextAlignment) {
+            switch (layoutDirection, multilineTextAlignment) {
+            case (.leftToRight, .leading):
+                self = .left
+            case (.rightToLeft, .leading):
+                self = .right
+            case (_, .center):
+                self = .center
+            case (.leftToRight, .trailing):
+                self = .right
+            case (.rightToLeft, .trailing):
+                self = .left
+            default:
+                self = .natural
+            }
         }
     }
 

Sources/MarkdownUI/Shared/Markdown.swift

@@ -0,0 +1,136 @@
+#if canImport(Combine) && !os(watchOS)
+
+    import Combine
+    import CombineSchedulers
+    import CommonMark
+    import Foundation
+    import NetworkImage
+
+    #if os(macOS)
+        import AppKit
+    #elseif canImport(UIKit)
+        import UIKit
+    #endif
+
+    @available(macOS 11.0, iOS 14.0, tvOS 14.0, *)
+    final class MarkdownRenderer: ObservableObject {
+        struct Environment {
+            static let `default` = Environment(
+                textAttachments: textAttachments(for:baseURL:),
+                scheduler: DispatchQueue.main.eraseToAnyScheduler()
+            )
+
+            static let synchronous = Environment(
+                textAttachments: syncTextAttachments(for:baseURL:),
+                scheduler: DispatchQueue.immediateScheduler.eraseToAnyScheduler()
+            )
+
+            let textAttachments: (Set<String>, URL?) -> AnyPublisher<[String: NSTextAttachment], Never>
+            let scheduler: AnySchedulerOf<DispatchQueue>
+        }
+
+        @Published private(set) var attributedString: NSAttributedString
+
+        init(
+            document: Document,
+            baseURL: URL?,
+            writingDirection: NSWritingDirection,
+            alignment: NSTextAlignment,
+            style: MarkdownStyle,
+            environment: Environment
+        ) {
+            attributedString = NSAttributedString(
+                document: document,
+                writingDirection: writingDirection,
+                alignment: alignment,
+                style: style
+            )
+
+            let urls = document.imageURLs
+
+            if !urls.isEmpty {
+                environment.textAttachments(urls, baseURL)
+                    .map { attachments in
+                        NSAttributedString(
+                            document: document,
+                            attachments: attachments,
+                            writingDirection: writingDirection,
+                            alignment: alignment,
+                            style: style
+                        )
+                    }
+                    .receive(on: environment.scheduler)
+                    .assign(to: &$attributedString)
+            }
+        }
+    }
+
+    @available(macOS 10.15, iOS 13.0, tvOS 13.0, *)
+    private func textAttachments(
+        for urls: Set<String>,
+        baseURL: URL?
+    ) -> AnyPublisher<[String: NSTextAttachment], Never> {
+        let attachmentURLs = urls.compactMap {
+            URL(string: $0, relativeTo: baseURL)
+        }
+
+        guard !attachmentURLs.isEmpty else {
+            return Just([:]).eraseToAnyPublisher()
+        }
+
+        let textAttachmentPairs = attachmentURLs.map { url in
+            ImageDownloader.shared.image(for: url).map { image -> (String, NSTextAttachment) in
+                let attachment = ImageAttachment()
+                attachment.image = image
+
+                return (url.relativeString, attachment)
+            }
+        }
+
+        return Publishers.MergeMany(textAttachmentPairs)
+            .collect()
+            .map { Dictionary($0, uniquingKeysWith: { _, last in last }) }
+            .replaceError(with: [:])
+            .eraseToAnyPublisher()
+    }
+
+    @available(macOS 10.15, iOS 13.0, tvOS 13.0, *)
+    private func syncTextAttachments(
+        for urls: Set<String>,
+        baseURL: URL?
+    ) -> AnyPublisher<[String: NSTextAttachment], Never> {
+        let attachmentURLs = urls.compactMap {
+            URL(string: $0, relativeTo: baseURL)
+        }
+
+        guard !attachmentURLs.isEmpty else {
+            return Just([:]).eraseToAnyPublisher()
+        }
+
+        var result: [String: NSTextAttachment] = [:]
+
+        for url in attachmentURLs {
+            guard let data = try? Data(contentsOf: url),
+                  let image = image(from: data) else { continue }
+
+            let attachment = ImageAttachment()
+            attachment.image = image
+
+            result[url.relativeString] = attachment
+        }
+
+        return Just(result).eraseToAnyPublisher()
+    }
+
+    #if os(macOS)
+        private func image(from data: Data) -> NSImage? {
+            NSImage(data: data)
+        }
+
+    #elseif canImport(UIKit)
+        private func image(from data: Data) -> UIImage? {
+            UIImage(data: data, scale: UIScreen.main.scale)
+        }
+    #endif
+
+#endif