refactor: Use GutenbergKit configuration builder (#24662)

* refactor: Use GutenbergKit configuration builder

Adopt the latest patterns to embrace immutable configuration.

* Adopt GutenbergKit EditorConfigurationBuilder

* Clean up Editor Configuration initialization

* Fix a Core Data threading issue

* Load the post when starting the editor

* Fix JSON conversion issue

* Set the postID and postType, if present

* build: Update GutenbergKit version

---------

Co-authored-by: Jeremy Massel <[email protected]>

Author: dcalhoun

Modules/Package.resolved

@@ -53,7 +53,7 @@ let package = Package(
         .package(url: "https://github.com/zendesk/support_sdk_ios", from: "8.0.3"),
         // We can't use wordpress-rs branches nor commits here. Only tags work.
         .package(url: "https://github.com/Automattic/wordpress-rs", revision: "alpha-20250901"),
-        .package(url: "https://github.com/wordpress-mobile/GutenbergKit", from: "0.8.0"),
+        .package(url: "https://github.com/wordpress-mobile/GutenbergKit", from: "0.8.1-alpha.2"),
         .package(
             url: "https://github.com/Automattic/color-studio",
             revision: "bf141adc75e2769eb469a3e095bdc93dc30be8de"

Modules/Package.swift

@@ -103,6 +103,13 @@ public final class WordPressOrgRestApi: NSObject {
         await perform(.get, path: path, parameters: parameters, options: options)
     }
 
+    public func get(
+        path: String,
+        parameters: [String: Any]? = nil
+    ) async -> WordPressAPIResult<Data, WordPressOrgRestApiError> {
+        await perform(.get, path: path, parameters: parameters) { $0 }
+    }
+
     public func post<Success: Decodable>(
         path: String,
         parameters: [String: Any]? = nil,

Modules/Sources/WordPressKit/WordPressOrgRestApi.swift

@@ -132,6 +132,16 @@ public extension AbstractPost {
         ]
     }
 
+    /// The post type as recorded in the `post_type` column of `wp_posts`
+    ///
+    var wpPostType: String {
+        return switch self {
+            case is Post: "post"
+            case is Page: "page"
+            default: preconditionFailure("Unknown post type")
+        }
+    }
+
     var analyticsPostType: String? {
         switch self {
         case is Post:

Sources/WordPressData/Swift/AbstractPost.swift

@@ -21,28 +21,20 @@ final class BlockEditorCache {
 
     // MARK: - Block Settings
 
-    func saveBlockSettings(_ settings: [String: Any], for blogID: TaggedManagedObjectID<Blog>) {
+    func saveBlockSettings(_ settings: Data, for blogID: TaggedManagedObjectID<Blog>) throws {
         let fileURL = makeBlockSettingsURL(for: blogID)
-
-        do {
-            let data = try JSONSerialization.data(withJSONObject: settings, options: [.prettyPrinted])
-            try data.write(to: fileURL)
-        } catch {
-            DDLogError("Failed to save block editor settings: \(error)")
-        }
+        try settings.write(to: fileURL)
     }
 
-    func getBlockSettings(for blogID: TaggedManagedObjectID<Blog>) -> [String: Any]? {
+    func getBlockSettings(for blogID: TaggedManagedObjectID<Blog>) -> Data? {
         let fileURL = makeBlockSettingsURL(for: blogID)
 
         guard FileManager.default.fileExists(atPath: fileURL.path) else {
             return nil
         }
 
         do {
-            let data = try Data(contentsOf: fileURL)
-            let object = try JSONSerialization.jsonObject(with: data, options: [])
-            return object as? [String: Any]
+            return try Data(contentsOf: fileURL)
         } catch {
             DDLogError("Failed to load block editor settings: \(error)")
             // If the file is corrupted, delete it

WordPress/Classes/Services/BlockEditorCache.swift

@@ -4,11 +4,14 @@ import WordPressKit
 import WordPressShared
 
 final class RawBlockEditorSettingsService {
+
     private let blog: Blog
-    private var refreshTask: Task<[String: Any], Error>?
+    private var refreshTask: Task<Data, Error>?
+    private let dotOrgRestAPI: WordPressOrgRestApi
 
     init(blog: Blog) {
         self.blog = blog
+        self.dotOrgRestAPI = WordPressOrgRestApi(blog: blog)!
     }
 
     private static var services: [TaggedManagedObjectID<Blog>: RawBlockEditorSettingsService] = [:]
@@ -24,27 +27,6 @@ final class RawBlockEditorSettingsService {
         return service
     }
 
-    @MainActor
-    private func fetchSettingsFromAPI() async throws -> [String: Any] {
-        guard let remoteAPI = WordPressOrgRestApi(blog: blog) else {
-            throw URLError(.unknown) // Should not happen
-        }
-        let result = await remoteAPI.get(path: "/wp-block-editor/v1/settings")
-        switch result {
-        case .success(let response):
-            guard let dictionary = response as? [String: Any] else {
-                throw NSError(domain: "RawBlockEditorSettingsService", code: 1, userInfo: [NSLocalizedDescriptionKey: "Invalid response format"])
-            }
-            let blogID = TaggedManagedObjectID(blog)
-            Task {
-                await saveSettingsInBackground(dictionary, for: blogID)
-            }
-            return dictionary
-        case .failure(let error):
-            throw error
-        }
-    }
-
     /// Refreshes the editor settings in the background.
     func refreshSettings() {
         Task { @MainActor in
@@ -53,7 +35,7 @@ final class RawBlockEditorSettingsService {
     }
 
     @MainActor
-    private func fetchSettings() async throws -> [String: Any] {
+    private func fetchSettings() async throws -> Data {
         if let task = refreshTask {
             return try await task.value
         }
@@ -70,23 +52,52 @@ final class RawBlockEditorSettingsService {
         return try await task.value
     }
 
+    private func fetchSettingsFromAPI() async throws -> Data {
+
+        let response: WordPressAPIResult<Data, WordPressOrgRestApiError> = await dotOrgRestAPI.get(
+            path: "/wp-block-editor/v1/settings"
+        )
+
+        let data = try response.get() // Unwrap the result type
+
+        let blogID = TaggedManagedObjectID(blog)
+        saveSettingsInBackground(data, for: blogID)
+
+        return data
+    }
+
     /// Returns cached settings if available. If not, fetches the settings from
     /// the network.
     @MainActor
-    func getSettings() async throws -> [String: Any] {
+    func getSettings() async throws -> Data {
         // Return cached settings if available
         let blogID = TaggedManagedObjectID(blog)
         if let cachedSettings = await loadSettingsInBackground(for: blogID) {
             return cachedSettings
         }
         return try await fetchSettings()
     }
+
+    @MainActor
+    func getSettingsString() async throws -> String {
+        let data = try await getSettings()
+        guard let string = String(data: data, encoding: .utf8) else {
+            throw CocoaError(.fileReadCorruptFile)
+        }
+        return string
+    }
 }
 
-private func saveSettingsInBackground(_ settings: [String: Any], for blogID: TaggedManagedObjectID<Blog>) async {
-    BlockEditorCache.shared.saveBlockSettings(settings, for: blogID)
+private func saveSettingsInBackground(_ settings: Data, for blogID: TaggedManagedObjectID<Blog>) {
+    Task {
+        do {
+            try BlockEditorCache.shared.saveBlockSettings(settings, for: blogID)
+        } catch {
+            wpAssertionFailure("Unable to save block settings", userInfo: ["error": error])
+        }
+    }
 }
 
-private func loadSettingsInBackground(for blogID: TaggedManagedObjectID<Blog>) async -> [String: Any]? {
+private func loadSettingsInBackground(for blogID: TaggedManagedObjectID<Blog>) async -> Data? {
     BlockEditorCache.shared.getBlockSettings(for: blogID)
 }

WordPress/Classes/Services/RawBlockEditorSettingsService.swift

@@ -0,0 +1,82 @@
+import Foundation
+import GutenbergKit
+import WordPressData
+import WordPressShared
+
+extension EditorConfiguration {
+    init(blog: Blog, keychain: KeychainAccessible = KeychainUtils()) {
+        let selfHostedApiUrl = blog.restApiRootURL ?? blog.url(withPath: "wp-json/")
+        let applicationPassword = try? blog.getApplicationToken(using: keychain)
+        let shouldUseWPComRestApi = applicationPassword == nil && blog.isAccessibleThroughWPCom()
+
+        let siteApiRoot: String?
+        if applicationPassword != nil {
+            siteApiRoot = selfHostedApiUrl
+        } else {
+            siteApiRoot = shouldUseWPComRestApi ? blog.wordPressComRestApi?.baseURL.absoluteString : selfHostedApiUrl
+        }
+
+        let siteId = blog.dotComID?.stringValue
+        let siteDomain = blog.primaryDomainAddress
+        let authToken = blog.authToken ?? ""
+        var authHeader = "Bearer \(authToken)"
+
+        if let appPassword = applicationPassword, let username = blog.username {
+            let credentials = "\(username):\(appPassword)"
+            if let credentialsData = credentials.data(using: .utf8) {
+                let base64Credentials = credentialsData.base64EncodedString()
+                authHeader = "Basic \(base64Credentials)"
+            }
+        }
+
+        // Must provide both namespace forms to detect usages of both forms in third-party code
+        var siteApiNamespace: [String] = []
+        if shouldUseWPComRestApi {
+            if let siteId {
+                siteApiNamespace.append("sites/\(siteId)/")
+            }
+            siteApiNamespace.append("sites/\(siteDomain)/")
+        }
+
+        var builder = EditorConfigurationBuilder()
+            .setSiteApiNamespace(siteApiNamespace)
+            .setNamespaceExcludedPaths(["/wpcom/v2/following/recommendations", "/wpcom/v2/following/mine"])
+            .setAuthHeader(authHeader)
+            .setShouldUseThemeStyles(FeatureFlag.newGutenbergThemeStyles.enabled)
+            // Limited to Jetpack-connected sites until editor assets endpoint is available in WordPress core
+            .setShouldUsePlugins(Self.shouldEnablePlugins(for: blog, appPassword: applicationPassword))
+            .setLocale(WordPressComLanguageDatabase().deviceLanguage.slug)
+
+        if let blogUrl = blog.url {
+            builder = builder.setSiteUrl(blogUrl)
+        }
+
+        if let siteApiRoot {
+            builder = builder.setSiteApiRoot(siteApiRoot)
+
+            if var editorAssetsEndpoint = URL(string: siteApiRoot) {
+                editorAssetsEndpoint.appendPathComponent("wpcom/v2/")
+                if let namespace = siteApiNamespace.first {
+                    editorAssetsEndpoint.appendPathComponent(namespace)
+                }
+
+                editorAssetsEndpoint.appendPathComponent("editor-assets")
+                builder = builder.setEditorAssetsEndpoint(editorAssetsEndpoint)
+            }
+        }
+
+        self = builder.build()
+    }
+
+    /// Returns true if the plugins should be enabled for the given blog.
+    /// This is used to determine if the editor should load third-party
+    /// plugins providing blocks.
+    static func shouldEnablePlugins(for blog: Blog, appPassword: String? = nil) -> Bool {
+        // Requires a Jetpack until editor assets endpoint is available in WordPress core.
+        // Requires a WP.com Simple site or an application password to authenticate all REST
+        // API requests, including those originating from non-core blocks.
+        return RemoteFeatureFlag.newGutenbergPlugins.enabled() &&
+            blog.isAccessibleThroughWPCom() &&
+            (blog.isHostedAtWPcom || appPassword != nil)
+    }
+}

WordPress/Classes/Utility/Editor/EditorConfiguration+Blog.swift

@@ -172,7 +172,7 @@ final class MySiteViewController: UIViewController, UIScrollViewDelegate, NoSite
 
         if RemoteFeatureFlag.newGutenberg.enabled() {
             GutenbergKit.EditorViewController.warmup(
-                configuration: blog.flatMap({ EditorConfiguration.init(blog: $0) }) ?? .default
+                configuration: blog.flatMap { EditorConfiguration(blog: $0) } ?? .default
             )
         }
     }

WordPress/Classes/ViewRelated/Blog/My Site/MySiteViewController.swift

@@ -35,8 +35,9 @@ final class CommentGutenbergEditorViewController: UIViewController {
     override func viewDidLoad() {
         super.viewDidLoad()
 
-        var configuration = EditorConfiguration(content: initialContent ?? "")
-        configuration.hideTitle = true
+        let configuration = EditorConfigurationBuilder(content: initialContent ?? "")
+            .setShouldHideTitle(true)
+            .build()
 
         let editorVC = GutenbergKit.EditorViewController(configuration: configuration)
         editorVC.delegate = self