Add new "Publishing" sheet

Modules/Sources/WordPressUI/Views/SiteIconView.swift

@@ -13,7 +13,11 @@ public struct SiteIconView: View {
 
     public var body: some View {
         contents
-            .clipShape(RoundedRectangle(cornerRadius: 6))
+            .clipShape(RoundedRectangle(cornerRadius: cornerRadius))
+    }
+
+    private var cornerRadius: CGFloat {
+        if #available(iOS 26, *) { 10 } else { 6 }
     }
 
     @ViewBuilder

Sources/WordPressData/Swift/PublicizeInfo+CoreDataClass.swift

@@ -31,7 +31,7 @@ public class PublicizeInfo: NSManagedObject {
     }
 
     /// A value-type representation for Publicize auto-sharing usage.
-    public struct SharingLimit {
+    public struct SharingLimit: Hashable {
         /// The remaining shares available for use.
         public let remaining: Int
 

WordPress/Classes/Services/PostCoordinator.swift

@@ -128,6 +128,43 @@ class PostCoordinator: NSObject {
         }
     }
 
+    /// Publishes the post according to the current settings and user capabilities.
+    ///
+    /// - warning: Before publishing, ensure that the media for the post got
+    /// uploaded. Managing media is not the responsibility of `PostRepository.`
+    ///
+    /// - parameter changes: The set of changes apply to the post together
+    /// with the publishing options.
+    @MainActor
+    func publish_v2(_ post: AbstractPost, parameters: RemotePostUpdateParameters) async throws {
+        wpAssert(post.isOriginal())
+        wpAssert(post.isStatus(in: [.draft, .pending]))
+
+        await pauseSyncing(for: post)
+        defer { resumeSyncing(for: post) }
+
+        var parameters = parameters
+        if parameters.status == nil {
+            parameters.status = Post.Status.publish.rawValue
+        }
+        if parameters.date == nil {
+            // If the post was previously scheduled for a different date,
+            // the app has to send a new value to override it.
+            parameters.date = post.shouldPublishImmediately() ? nil : Date()
+        }
+
+        do {
+            let repository = PostRepository(coreDataStack: coreDataStack)
+            try await repository.save(post, changes: parameters)
+            didPublish(post)
+            show(PostCoordinator.makeUploadSuccessNotice(for: post))
+        } catch {
+            trackError(error, operation: "post-publish", post: post)
+            handleError(error, for: post)
+            throw error
+        }
+    }
+
     @MainActor
     private func didPublish(_ post: AbstractPost) {
         if post.status == .scheduled {

WordPress/Classes/Utility/BuildInformation/FeatureFlag.swift

@@ -26,6 +26,7 @@ public enum FeatureFlag: Int, CaseIterable {
     case pluginManagementOverhaul
     case newsletterSubscribers
     case newStats
+    case newPublishingSheet
 
     /// Returns a boolean indicating if the feature is enabled.
     ///
@@ -82,6 +83,8 @@ public enum FeatureFlag: Int, CaseIterable {
             return true
         case .newStats:
             return false
+        case .newPublishingSheet:
+            return false
         }
     }
 
@@ -125,6 +128,7 @@ extension FeatureFlag {
         case .readerGutenbergCommentComposer: "Gutenberg Comment Composer"
         case .newsletterSubscribers: "Newsletter Subscribers"
         case .newStats: "New Stats"
+        case .newPublishingSheet: "New Publishing Sheet"
         }
     }
 }

WordPress/Classes/ViewRelated/Jetpack/Social/JetpackSocialNoConnectionView.swift

@@ -5,7 +5,7 @@ import WordPressUI
 
 struct JetpackSocialNoConnectionView: View {
 
-    private let viewModel: JetpackSocialNoConnectionViewModel
+    let viewModel: JetpackSocialNoConnectionViewModel
 
     var body: some View {
         VStack(alignment: .leading, spacing: 12.0) {

WordPress/Classes/ViewRelated/Post/PostSettings/PostSettings.swift

@@ -25,6 +25,7 @@ struct PostSettings: Hashable {
     // MARK: - Post-specific
     var postFormat: String?
     var isStickyPost = false
+    var sharing: PostSocialSharingSettings?
 
     // MARK: - Page-specific
     var parentPageID: Int?
@@ -36,7 +37,7 @@ struct PostSettings: Hashable {
         excerpt = post.mt_excerpt ?? ""
         slug = post.wp_slug ?? ""
         status = post.status ?? .draft
-        publishDate = post.dateCreated
+        publishDate = post.shouldPublishImmediately() ? nil : post.dateCreated
         password = post.password
 
         if let authorID = post.authorID?.intValue, authorID > 0 {
@@ -57,6 +58,7 @@ struct PostSettings: Hashable {
             categoryIDs = Set((post.categories ?? []).compactMap {
                 $0.categoryID?.intValue
             })
+            sharing = PostSocialSharingSettings.make(for: post)
         case let page as Page:
             parentPageID = page.parentID?.intValue
         default:
@@ -129,6 +131,22 @@ struct PostSettings: Hashable {
             if post.isStickyPost != isStickyPost {
                 post.isStickyPost = isStickyPost
             }
+
+            if let sharing {
+                for connection in sharing.services.flatMap(\.connections) {
+                    let keyringID = NSNumber(value: connection.keyringID)
+                    if !post.publicizeConnectionDisabledForKeyringID(keyringID) != connection.enabled {
+                        if connection.enabled {
+                            post.enablePublicizeConnectionWithKeyringID(keyringID)
+                        } else {
+                            post.disablePublicizeConnectionWithKeyringID(keyringID)
+                        }
+                    }
+                }
+                if post.publicizeMessage != sharing.message {
+                    post.publicizeMessage = sharing.message
+                }
+            }
         case let page as Page:
             if page.parentID?.intValue != parentPageID {
                 page.parentID = parentPageID.map { NSNumber(value: $0) }
@@ -186,3 +204,70 @@ extension PostSettings {
             .map { $0.stringByDecodingXMLCharacters() }
     }
 }
+
+/// A value-type representation of `PublicizeService` for the current blog that's simplified for the auto-sharing flow.
+struct PostSocialSharingSettings: Hashable {
+    var services: [Service]
+    var message: String
+    var sharingLimit: PublicizeInfo.SharingLimit?
+
+    struct Service: Hashable {
+        let name: PublicizeService.ServiceName
+        var connections: [Connection]
+    }
+
+    struct Connection: Hashable {
+        let account: String
+        let keyringID: Int
+        var enabled: Bool
+    }
+
+    static func make(for post: Post) -> PostSocialSharingSettings? {
+        guard let context = post.managedObjectContext else {
+            wpAssertionFailure("missing moc")
+            return nil
+        }
+
+        let connections = post.blog.sortedConnections
+
+        // first, build a dictionary to categorize the connections.
+        var connectionsMap = [PublicizeService.ServiceName: [PublicizeConnection]]()
+        connections.filter { !$0.requiresUserAction() }.forEach { connection in
+            let name = PublicizeService.ServiceName(rawValue: connection.service) ?? .unknown
+            var serviceConnections = connectionsMap[name] ?? []
+            serviceConnections.append(connection)
+            connectionsMap[name] = serviceConnections
+        }
+
+        let publicizeServices: [PublicizeService]
+        do {
+            publicizeServices = try PublicizeService.allPublicizeServices(in: context)
+        } catch {
+            wpAssertionFailure("failed to fetch services", userInfo: ["error": error.localizedDescription])
+            return nil
+        }
+
+        let services = publicizeServices.compactMap { service -> PostSocialSharingSettings.Service? in
+            // skip services without connections.
+            guard let serviceConnections = connectionsMap[service.name],
+                  !serviceConnections.isEmpty else {
+                return nil
+            }
+
+            return PostSocialSharingSettings.Service(
+                name: service.name,
+                connections: serviceConnections.map {
+                    .init(account: $0.externalDisplay,
+                          keyringID: $0.keyringConnectionID.intValue,
+                          enabled: !post.publicizeConnectionDisabledForKeyringID($0.keyringConnectionID))
+                }
+            )
+        }
+
+        return PostSocialSharingSettings(
+            services: services,
+            message: post.publicizeMessage ?? post.titleForDisplay(),
+            sharingLimit: post.blog.sharingLimit
+        )
+    }
+}