Keep Article drafts after relaunch (#136)

* Keep Article drafts after relaunch

Rich text drafts left in the composer after closing the Article editor lived
only in process memory, so quitting Telegram discarded them while regular
drafts survived.

Store them in the item cache under richTextComposerDrafts, keyed by peer and
thread like iOS, restore them when the chat opens, and remove them once the
draft is sent or cleared.

* Rework Article draft persistence after review

Store drafts in an app-specific item cache collection and keep the
entry type in its own file, so the test harnesses that paste
ChatRichTextDraftStore.swift compile again. Keep the stored copy when
the rich editor takes the draft, load it only after the stored text
draft is applied, reload it when the thread changes in place, and drop
reads that return for another thread. Clear the stored copy when a
message is sent, and store inline editor edits half a second after the
last change and when the chat closes.

* Keep Article drafts apart when the topic changes in place

Finish a pending inline save for the old topic, fill the inline editor with
the new topic's draft even when it has focus, write the draft only when it
changed, and keep the business link editor out of the saved draft slot.

* Keep unshown Article drafts and save the editor window on quit

Reload the inline draft only when the topic or chat really changes, so
typing in a topic no longer reseeds and erases it, and clear the editor's
undo history on a switch. A text send no longer removes a saved Article,
and an Article that wasn't shown is not removed when the draft is cleared.
The pending inline save and the Article editor window's content are stored
on quit; the window also autosaves while open, only when its content
changed. A draft with media blocks is edited inline, so Backspace no longer
deletes the whole draft.

* Respect the editor switch and keep editor drafts apart

A saved Article isn't restored while the server turns the rich text
editor off and is kept like one skipped because of input text. Emptying
the editor window removes the saved copy, but nothing is saved before
the window shows its draft. Quick reply, away, greeting and business
link editors no longer share the chat's in-memory slot. The
chat-date-context fixture and the key isolation test are updated.

Author: null00x

packages/ChatUI/Sources/ChatUI/ChatController.swift

@@ -8155,6 +8155,7 @@ open class ChatController<Context: AccountContextProtocol>: TelegramGenericViewC
             }
             guard let initialData = combinedInitialData.initialData else {
                 self.genericView.inputView.updateInterface(with: self.chatInteraction)
+                self.chatInteraction.loadPersistentRichTextDraft()
                 return
             }
 
@@ -8295,6 +8296,7 @@ open class ChatController<Context: AccountContextProtocol>: TelegramGenericViewC
 
 
             self.state = self.chatInteraction.presentation.state == .selecting ? .Edit : .Normal
+            self.chatInteraction.loadPersistentRichTextDraft()
 
 
         } |> map {_ in}

packages/ChatUI/Sources/ChatUI/ChatInputView.swift

@@ -90,6 +90,7 @@ public final class ChatInputContainerView: FlippableView {
     public var sendRichDraft: (() -> Void)?
     /// The inline editor's content grew/shrank → host propagates the new input height.
     public var richDraftHeightChanged: (() -> Void)?
+    public var richDraftContentChanged: (() -> Void)?
 
     public let accessory: ChatInputAccessory
     public let contentView: FlippableView
@@ -245,6 +246,9 @@ public final class ChatInputContainerView: FlippableView {
                 current.onSend = { [weak self] in
                     self?.sendRichDraft?()
                 }
+                current.onEditorContentChange = { [weak self] in
+                    self?.richDraftContentChanged?()
+                }
                 current.onEditorHeightChange = { [weak self] in
                     guard let self = self, let preview = self.richDraftPreview else { return }
                     // Editing emptied the draft (e.g. ⌘A + Delete removed all text AND media) → drop the rich
@@ -693,6 +697,8 @@ public class ChatInputView: View, Notifable {
     private let slowModeUntilDisposable = MetaDisposable()
     private let accessoryDisposable:MetaDisposable = MetaDisposable()
     private let richDraftDisposable = MetaDisposable()
+    private let inlineRichDraftStoreDisposable = MetaDisposable()
+    private var hasPendingInlineRichDraftStore = false
     private let incomingTypingDraftDisposable = MetaDisposable()
     private var incomingTypingDraftKey: PeerAndThreadId?
     private var canStopIncomingStreamingMessage = false
@@ -784,9 +790,17 @@ public class ChatInputView: View, Notifable {
         container.sendRichDraft = { [weak self] in
             self?.sendInlineRichDraft()
         }
+        chatInteraction.storePendingRichTextDraft = { [weak self] in
+            guard let self, self.hasPendingInlineRichDraftStore else {
+                return
+            }
+            self.cancelInlineRichDraftStore()
+            self.storeInlineRichDraft(threadId: self.chatInteraction.chatLocation.threadId)
+        }
         // Just before any send reads the stored draft, write the live inline-editor content into it (or into
         // the composer text when the content reduced to plain) — so the send button posts the edited content.
         chatInteraction.flushRichTextDraft = { [weak self] in
+            self?.cancelInlineRichDraftStore()
             guard let self = self, let preview = self.container.richDraftPreview, preview.isInlineEditing,
                   let blocks = preview.currentOutgoing() else { return }
             switch composeRichMessage(from: blocks, media: preview.currentMedia()) {
@@ -810,6 +824,9 @@ public class ChatInputView: View, Notifable {
         container.richDraftHeightChanged = { [weak self] in
             self?.inputDidUpdateLayout(animated: true)
         }
+        container.richDraftContentChanged = { [weak self] in
+            self?.scheduleInlineRichDraftStore()
+        }
         richDraftDisposable.set((chatInteraction.richTextDraftSignal |> deliverOnMainQueue).start(next: { [weak self] page in
             guard let self = self else { return }
             if self.container.setRichDraft(page, theme: self.currentChatTheme ?? theme) {
@@ -829,6 +846,29 @@ public class ChatInputView: View, Notifable {
         self.bindIncomingTypingDraft(for: chatInteraction.chatLocation, animated: false)
     }
 
+    private func scheduleInlineRichDraftStore() {
+        hasPendingInlineRichDraftStore = true
+        let threadId = chatInteraction.chatLocation.threadId
+        inlineRichDraftStoreDisposable.set((Signal<Void, NoError>.single(Void()) |> delay(0.5, queue: .mainQueue())).start(completed: { [weak self] in
+            self?.storeInlineRichDraft(threadId: threadId)
+        }))
+    }
+
+    private func cancelInlineRichDraftStore() {
+        hasPendingInlineRichDraftStore = false
+        inlineRichDraftStoreDisposable.set(nil)
+    }
+
+    private func storeInlineRichDraft(threadId: Int64?) {
+        hasPendingInlineRichDraftStore = false
+        guard let preview = container.richDraftPreview, preview.isInlineEditing, let blocks = preview.currentOutgoing() else {
+            return
+        }
+        if let page = richTextInstantPage(from: blocks, media: preview.currentMedia()) {
+            chatInteraction.storeRichTextDraftSnapshot(page, threadId: threadId)
+        }
+    }
+
     private func bindIncomingTypingDraft(for chatLocation: ChatLocation, animated: Bool) {
         let key = PeerAndThreadId(peerId: chatLocation.peerId, threadId: chatLocation.threadId)
         guard self.incomingTypingDraftKey != key else {
@@ -900,20 +940,13 @@ public class ChatInputView: View, Notifable {
         window.remove(object: self, for: .Z, modifierFlags: [.command], forceCheckFlags: true)
         window.remove(object: self, for: .Z, modifierFlags: [.command, .shift], forceCheckFlags: true)
 
-        // Whether the draft is shown in the LIVE inline editor (vs the read-only media preview). Matches the
-        // preview's block-based decision (NOT `media.isEmpty`, which can be non-empty for a text-only draft):
-        // a draft with no unsupported-media block is the live inline editor. Both cases get a window Return
+        // Whether the draft is shown in the LIVE inline editor (vs the read-only preview). On macOS 12+ the
+        // preview hosts every draft, media blocks included, in the inline editor. Both cases get a window Return
         // handler honoring the send preference; the inline case rejects non-send Returns so the editor adds a
         // newline, while Delete/⌘Z go to the editor.
         let isInlineEditable: Bool = {
-            guard #available(macOS 12, *), let draft = chatInteraction.richTextDraft else { return false }
-            let hasUninlineableBlock = draft.blocks.contains { block in
-                switch block {
-                case .video, .audio, .map, .collage, .slideshow: return true
-                default: return false
-                }
-            }
-            return !hasUninlineableBlock
+            guard #available(macOS 12, *) else { return false }
+            return chatInteraction.richTextDraft != nil
         }()
 
         if isInlineEditable {
@@ -1232,6 +1265,16 @@ public class ChatInputView: View, Notifable {
         if let value = value as? ChatPresentationInterfaceState {
             if let oldValue = oldValue as? ChatPresentationInterfaceState, value.chatLocation != oldValue.chatLocation {
                 self.bindIncomingTypingDraft(for: value.chatLocation, animated: animated)
+                if value.chatLocation.peerId != oldValue.chatLocation.peerId || value.chatLocation.threadId != oldValue.chatLocation.threadId {
+                    if self.hasPendingInlineRichDraftStore {
+                        self.storeInlineRichDraft(threadId: oldValue.chatLocation.threadId)
+                    }
+                    self.cancelInlineRichDraftStore()
+                    self.container.richDraftPreview?.reseedEditorOnNextUpdate()
+                    self.deletedRichDraft = nil
+                    self.chatInteraction.reloadRichTextDraft()
+                    self.chatInteraction.loadPersistentRichTextDraft()
+                }
             }
             let sendState = ChatInputView.sendButtonState(
                 from: value,
@@ -2144,6 +2187,10 @@ public class ChatInputView: View, Notifable {
 
 
     deinit {
+        if self.hasPendingInlineRichDraftStore {
+            self.storeInlineRichDraft(threadId: self.chatInteraction.chatLocation.threadId)
+        }
+        self.inlineRichDraftStoreDisposable.dispose()
         self.accessoryDisposable.dispose()
         self.rtfAttachmentsDisposable.dispose()
         self.slowModeUntilDisposable.dispose()

packages/ChatUI/Sources/ChatUI/ChatInterfaceInteraction.swift

@@ -498,31 +498,101 @@ public final class ChatInteraction : InterfaceObserver  {
     // composer (InstantPageV2) and sends as a `RichTextMessageAttribute`. nil when there is no rich draft.
     //
     // Backed by a process-global per-chat store so the draft survives the chat controller being torn down
-    // and reopened (the `ChatInteraction` is recreated each time). (Full cross-launch/cross-device sync —
-    // like iOS persisting it into the synchronizeable input state — is a follow-up.)
+    // and reopened (the `ChatInteraction` is recreated each time), and kept in the item cache like iOS so it
+    // survives a relaunch. (Cross-device sync is a follow-up.)
     private static let globalRichTextDrafts = ChatRichTextDraftStore<InstantPage>()
     private var richTextDraftKey: ChatRichTextDraftKey {
+        return richTextDraftKey(threadId: chatLocation.threadId)
+    }
+    private func richTextDraftKey(threadId: Int64?) -> ChatRichTextDraftKey {
         let isWelcome: Bool
         if case .welcomeMessages = mode.customChatContents?.kind {
             isWelcome = true
         } else {
             isWelcome = false
         }
-        return ChatRichTextDraftKey(accountId: context.account.id.int64, peerId: peerId.toInt64(), threadId: chatLocation.threadId, isWelcome: isWelcome)
+        return ChatRichTextDraftKey(accountId: context.account.id.int64, peerId: peerId.toInt64(), threadId: threadId, isWelcome: isWelcome, isCustomEditor: mode.customChatContents != nil || mode.customChatLink != nil)
     }
     private let richTextDraftPromise = ValuePromise<InstantPage?>(nil, ignoreRepeated: false)
+    private var persistentRichTextDraftId: EngineDataBuffer? {
+        return persistentRichTextDraftId(threadId: chatLocation.threadId)
+    }
+    private func persistentRichTextDraftId(threadId: Int64?) -> EngineDataBuffer? {
+        guard mode.customChatContents == nil, mode.customChatLink == nil else {
+            return nil
+        }
+        let id = EngineDataBuffer(length: 16)
+        id.setInt64(0, value: peerId.toInt64())
+        id.setInt64(8, value: threadId ?? 0)
+        return id
+    }
     public var richTextDraft: InstantPage? { ChatInteraction.globalRichTextDrafts.value(for: richTextDraftKey) }
     public var richTextDraftSignal: Signal<InstantPage?, NoError> { richTextDraftPromise.get() }
     public var flushRichTextDraft: (() -> Void)?
-    public func setRichTextDraft(_ page: InstantPage?) {
+    public var storePendingRichTextDraft: (() -> Void)?
+    public var storePendingRichTextEditorDraft: (() -> Void)?
+    private var unshownPersistentRichTextDraftKey: ChatRichTextDraftKey?
+    public func setRichTextDraft(_ page: InstantPage?, persist: Bool = true) {
         if ChatInteraction.globalRichTextDrafts.set(page, for: richTextDraftKey) {
             invalidateDeferredSendActions()
         }
         richTextDraftPromise.set(page)
+        if persist, page != nil || unshownPersistentRichTextDraftKey != richTextDraftKey {
+            unshownPersistentRichTextDraftKey = nil
+            storePersistentRichTextDraft(page, threadId: chatLocation.threadId)
+        }
+    }
+    public func storeRichTextDraftSnapshot(_ page: InstantPage, threadId: Int64?) {
+        let key = richTextDraftKey(threadId: threadId)
+        guard ChatInteraction.globalRichTextDrafts.value(for: key) != nil, ChatInteraction.globalRichTextDrafts.set(page, for: key) else {
+            return
+        }
+        invalidateDeferredSendActions()
+        storePersistentRichTextDraft(page, threadId: threadId)
+    }
+    public func persistRichTextDraft(_ page: InstantPage?) {
+        guard unshownPersistentRichTextDraftKey != richTextDraftKey else {
+            return
+        }
+        storePersistentRichTextDraft(page, threadId: chatLocation.threadId)
     }
     public func reloadRichTextDraft() {
         richTextDraftPromise.set(richTextDraft)
     }
+    public func loadPersistentRichTextDraft() {
+        guard richTextDraft == nil, let id = persistentRichTextDraftId else {
+            return
+        }
+        let key = richTextDraftKey
+        _ = (context.engine.data.get(TelegramEngine.EngineData.Item.ItemCache.Item(collectionId: ApplicationSpecificItemCacheCollectionId.richTextComposerDraft, id: id))
+        |> deliverOnMainQueue).start(next: { [weak self] entry in
+            guard let self, self.richTextDraftKey == key, let page = entry?.get(ChatRichTextDraftEntry.self)?.page else {
+                return
+            }
+            guard self.context.appConfiguration.isRichTextEditorEnabled, self.presentation.effectiveInput.inputText.isEmpty else {
+                self.unshownPersistentRichTextDraftKey = key
+                return
+            }
+            guard ChatInteraction.globalRichTextDrafts.value(for: key) == nil else {
+                return
+            }
+            self.unshownPersistentRichTextDraftKey = nil
+            if ChatInteraction.globalRichTextDrafts.set(page, for: key) {
+                self.invalidateDeferredSendActions()
+            }
+            self.richTextDraftPromise.set(page)
+        })
+    }
+    private func storePersistentRichTextDraft(_ page: InstantPage?, threadId: Int64?) {
+        guard let id = persistentRichTextDraftId(threadId: threadId) else {
+            return
+        }
+        if let page {
+            _ = context.engine.itemCache.put(collectionId: ApplicationSpecificItemCacheCollectionId.richTextComposerDraft, id: id, item: ChatRichTextDraftEntry(page: page)).start()
+        } else {
+            _ = context.engine.itemCache.remove(collectionId: ApplicationSpecificItemCacheCollectionId.richTextComposerDraft, id: id).start()
+        }
+    }
 
 
     public var hasSetDestructiveTimer: Bool {
@@ -1123,6 +1193,10 @@ public final class ChatInteraction : InterfaceObserver  {
 
 
     public func saveState(_ force:Bool = true, scrollState: ChatInterfaceHistoryScrollState? = nil, sync: Bool = false) {
+        if sync {
+            storePendingRichTextDraft?()
+            storePendingRichTextEditorDraft?()
+        }
 
         if mode.customChatContents != nil || mode.customChatLink != nil {
             return

packages/ChatUI/Sources/ChatUI/ChatRichTextDraftEntry.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Postbox
+import TelegramCore
+
+final class ChatRichTextDraftEntry: Codable {
+    let page: InstantPage
+
+    init(page: InstantPage) {
+        self.page = page
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: StringCodingKey.self)
+        let pageData = try container.decode(AdaptedPostboxDecoder.RawObjectData.self, forKey: "page")
+        self.page = InstantPage(decoder: PostboxDecoder(buffer: MemoryBuffer(data: pageData.data)))
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: StringCodingKey.self)
+        try container.encode(PostboxEncoder().encodeObjectToRawData(self.page), forKey: "page")
+    }
+}

packages/ChatUI/Sources/ChatUI/ChatRichTextDraftStore.swift

@@ -5,6 +5,7 @@ struct ChatRichTextDraftKey: Hashable {
     let peerId: Int64
     let threadId: Int64?
     let isWelcome: Bool
+    var isCustomEditor: Bool = false
 }
 
 final class ChatRichTextDraftRevision {

packages/ChatUI/Sources/ChatUI/ChatRichTextRowItem.swift

@@ -1330,6 +1330,7 @@ public final class RichTextDraftPreviewView: View {
     public var onSend: (() -> Void)?
     /// Fired when the inline editor's content height changes (the host re-measures the row).
     public var onEditorHeightChange: (() -> Void)?
+    public var onEditorContentChange: (() -> Void)?
 
     @available(macOS 12, *)
     private var richEditor: RichTextEditorView? { editorView as? RichTextEditorView }
@@ -1351,6 +1352,10 @@ public final class RichTextDraftPreviewView: View {
 
     /// True while the live inline editor is shown (vs the read-only preview).
     public var isInlineEditing: Bool { isEditable }
+    private var reseedsEditor = false
+    public func reseedEditorOnNextUpdate() {
+        reseedsEditor = true
+    }
 
     /// Undo / redo on the inline editor (host wires ⌘Z / ⌘⇧Z to these).
     public func undoInline() { if #available(macOS 12, *) { richEditor?.undo() } }
@@ -1425,6 +1430,7 @@ public final class RichTextDraftPreviewView: View {
                 return true
             }
             editor.onContentHeightChange = { [weak self] in self?.onEditorHeightChange?() }
+            editor.onFormatStateChange = { [weak self] in self?.onEditorContentChange?() }
             // Render custom-emoji atoms as the app's animated inline stickers (same provider as the modal
             // editor) — without this an inline draft's custom emoji draw as blanks.
             if let context = self.chatInteraction?.interactionContext {
@@ -1520,10 +1526,15 @@ public final class RichTextDraftPreviewView: View {
         // user is actively editing, the editor is the live source of truth — re-seeding (e.g. from our own
         // draft-sync round-trip) would reset the caret.
         let focused = (window?.firstResponder as? NSView).map { $0 === editor || $0.isDescendant(of: editor) } ?? false
-        if isNew || !focused {
+        if isNew || !focused || reseedsEditor {
+            let clearsUndo = reseedsEditor
+            reseedsEditor = false
             let (blocks, media) = richTextOutgoing(from: instantPage)
             self.mediaCache = media
             editor.setOutgoingBlocks(blocks)
+            if clearsUndo {
+                editor.removeAllUndoActions()
+            }
             editor.moveCaretToEnd()
         }
         return measureEditable(width: width)