@apollohg/react-native-rich-text-editor 2.0.0

package/ios/NativeEditorExpoView+AccessoryRetry.swift

@@ -0,0 +1,219 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func clearPendingEditorUpdateRetries() {
+        lastEditorUpdateJSONProp = nil
+        pendingEditorUpdateJSON = nil
+        pendingEditorUpdateResetJSON = nil
+        pendingEditorUpdateEditorId = nil
+        pendingEditorUpdateRevision = 0
+        appliedEditorUpdateRevision = 0
+        renderedRevision = nil
+        pendingEditorUpdateRetryScheduled = false
+        pendingEditorUpdateRetryEditorId = nil
+        pendingEditorUpdateRetryGeneration &+= 1
+    }
+
+    func clearPendingViewCommandUpdateRetry() {
+        pendingViewCommandUpdateJSON = nil
+        pendingViewCommandUpdateEditorId = nil
+        pendingViewCommandUpdateRetryScheduled = false
+        pendingViewCommandUpdateRetryGeneration &+= 1
+    }
+
+    func clearPendingEditableRetry() {
+        pendingEditableRetryValue = nil
+        pendingEditableRetryEditorId = nil
+        pendingEditableRetryScheduled = false
+        pendingEditableRetryGeneration &+= 1
+    }
+
+    func clearPendingThemeRetry() {
+        pendingThemeRetry.clear()
+    }
+
+    func clearPendingAtomsRetry() {
+        pendingAtomsRetry.clear()
+    }
+
+    func clearPendingAccessoryRetry() {
+        pendingAccessoryRetryActions = []
+        invalidatedAccessoryRetryActions.removeAll()
+        pendingAccessoryRetryEditorId = nil
+        pendingAccessoryRetryScheduled = false
+        pendingAccessoryRetryGeneration &+= 1
+    }
+
+    func clearPendingMentionSuggestionRetry() {
+        pendingMentionSuggestionRetry = nil
+        pendingMentionSuggestionRetryScheduled = false
+        pendingMentionSuggestionRetryGeneration &+= 1
+    }
+
+    func scheduleThemeRetry(_ themeJson: String?) {
+        guard let token = pendingThemeRetry.schedule(
+            json: themeJson,
+            editorId: richTextView.editorId,
+            maxAttempts: nil
+        ) else { return }
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard let retry = self.pendingThemeRetry.consume(token) else { return }
+            guard retry.editorId == self.richTextView.editorId else {
+                self.clearPendingThemeRetry()
+                return
+            }
+            guard retry.json == self.desiredThemeJSON else {
+                self.clearPendingThemeRetry()
+                return
+            }
+            self.setThemeJson(retry.json)
+        }
+    }
+
+    func scheduleAtomsRetry(_ atomsJson: String?) {
+        guard let token = pendingAtomsRetry.schedule(
+            json: atomsJson,
+            editorId: richTextView.editorId,
+            maxAttempts: Self.maxPendingUpdateRetryAttempts
+        ) else { return }
+        let delay = Self.nativeActionRetryDelay * Double(token.attempt)
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
+            guard let self else { return }
+            guard let retry = self.pendingAtomsRetry.consume(token) else { return }
+            guard retry.editorId == self.richTextView.editorId else {
+                self.clearPendingAtomsRetry()
+                return
+            }
+            guard retry.json == self.desiredAtomsJSON else {
+                self.clearPendingAtomsRetry()
+                return
+            }
+            self.setAtomsJson(retry.json)
+        }
+    }
+
+    func schedulePendingAtomsWakeIfNeeded() {
+        guard desiredAtomsJSON != lastAtomsJSON,
+              !pendingAtomsWakeScheduled
+        else { return }
+        clearPendingAtomsRetry()
+        pendingAtomsWakeScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.pendingAtomsWakeScheduled = false
+            guard self.desiredAtomsJSON != self.lastAtomsJSON else { return }
+            self.setAtomsJson(self.desiredAtomsJSON)
+        }
+    }
+
+    func prepareForInputAccessoryMutationOrRetry(_ action: PendingAccessoryRetryAction) -> Bool {
+        guard richTextView.editorId != 0, richTextView.textView.isFirstResponder else {
+            return true
+        }
+        guard richTextView.textView.prepareForExternalEditorUpdate() else {
+            scheduleAccessoryRetry(action)
+            return false
+        }
+        return true
+    }
+
+    func reloadInputViewsAfterPreparingOrRetry() {
+        guard prepareForInputAccessoryMutationOrRetry(.reloadInputViews) else { return }
+        richTextView.textView.reloadInputViews()
+        markAccessoryMutationSucceeded(.reloadInputViews)
+    }
+
+    private func scheduleAccessoryRetry(_ action: PendingAccessoryRetryAction) {
+        invalidatedAccessoryRetryActions.remove(action)
+        pendingAccessoryRetryActions.removeAll { $0 == action }
+        pendingAccessoryRetryActions.append(action)
+        pendingAccessoryRetryEditorId = richTextView.editorId
+        guard !pendingAccessoryRetryScheduled else { return }
+        pendingAccessoryRetryScheduled = true
+        pendingAccessoryRetryGeneration &+= 1
+        let retryGeneration = pendingAccessoryRetryGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard retryGeneration == self.pendingAccessoryRetryGeneration else { return }
+            guard self.pendingAccessoryRetryEditorId == self.richTextView.editorId else {
+                self.clearPendingAccessoryRetry()
+                return
+            }
+            let actions = self.pendingAccessoryRetryActions
+            self.pendingAccessoryRetryActions = []
+            self.pendingAccessoryRetryEditorId = nil
+            self.pendingAccessoryRetryScheduled = false
+            for index in actions.indices {
+                let action = actions[index]
+                guard retryGeneration == self.pendingAccessoryRetryGeneration else { return }
+                guard !self.invalidatedAccessoryRetryActions.contains(action) else {
+                    self.invalidatedAccessoryRetryActions.remove(action)
+                    continue
+                }
+                let generationBeforeAction = self.pendingAccessoryRetryGeneration
+                self.performAccessoryRetryAction(action)
+                guard self.pendingAccessoryRetryGeneration == generationBeforeAction else {
+                    let remainingIndex = actions.index(after: index)
+                    if remainingIndex < actions.endIndex {
+                        self.requeueUnprocessedAccessoryRetryActions(actions[remainingIndex...])
+                    }
+                    return
+                }
+            }
+            self.invalidatedAccessoryRetryActions.subtract(actions)
+        }
+    }
+
+    private func requeueUnprocessedAccessoryRetryActions(
+        _ actions: ArraySlice<PendingAccessoryRetryAction>
+    ) {
+        for action in actions {
+            guard !invalidatedAccessoryRetryActions.contains(action) else {
+                invalidatedAccessoryRetryActions.remove(action)
+                continue
+            }
+            pendingAccessoryRetryActions.removeAll { $0 == action }
+            pendingAccessoryRetryActions.append(action)
+        }
+        if !pendingAccessoryRetryActions.isEmpty {
+            pendingAccessoryRetryEditorId = richTextView.editorId
+        }
+    }
+
+    private func performAccessoryRetryAction(_ action: PendingAccessoryRetryAction) {
+        switch action {
+        case .reloadInputViews:
+            reloadInputViewsAfterPreparingOrRetry()
+        case .refreshMentionQuery:
+            refreshMentionQuery()
+        case .clearMentionQueryState:
+            clearMentionQueryStateAndHidePopover()
+        case .updateAccessoryToolbarVisibility:
+            updateAccessoryToolbarVisibility()
+        }
+    }
+
+    func markAccessoryMutationSucceeded(_ action: PendingAccessoryRetryAction) {
+        var invalidated: Set<PendingAccessoryRetryAction> = [action]
+        switch action {
+        case .refreshMentionQuery:
+            invalidated.insert(.clearMentionQueryState)
+        case .clearMentionQueryState:
+            if !hasActiveMentionQueryForCurrentAddons() {
+                invalidated.insert(.refreshMentionQuery)
+            }
+        case .reloadInputViews, .updateAccessoryToolbarVisibility:
+            break
+        }
+        invalidatePendingAccessoryRetries(invalidated)
+    }
+
+    private func invalidatePendingAccessoryRetries(_ actions: Set<PendingAccessoryRetryAction>) {
+        guard !actions.isEmpty else { return }
+        invalidatedAccessoryRetryActions.formUnion(actions)
+        pendingAccessoryRetryActions.removeAll { actions.contains($0) }
+    }
+
+}

package/ios/NativeEditorExpoView+Binding.swift

@@ -0,0 +1,268 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func handleEditorDestroyed(_ editorId: UInt64) {
+        guard editorId != 0 else { return }
+        guard richTextView.editorId == editorId || richTextView.textView.editorId == editorId else {
+            NativeEditorViewRegistry.shared.unregister(editorId: editorId, view: self)
+            return
+        }
+
+        richTextView.textView.discardTransientNativeInputForEditorRebind()
+        clearAutonomousErrorBinding()
+        NativeEditorViewRegistry.shared.unregister(editorId: editorId, view: self)
+        clearPendingEditorUpdateRetries()
+        clearPendingViewCommandUpdateRetry()
+        clearPendingEditableRetry()
+        clearPendingThemeRetry()
+        clearPendingAtomsRetry()
+        clearPendingAccessoryRetry()
+        clearPendingMentionSuggestionRetry()
+        lastMentionEventJSON = nil
+        _ = richTextView.textView.resignFirstResponder()
+        richTextView.editorId = 0
+        mentionQueryState = nil
+        _ = accessoryToolbar.setMentionSuggestions([])
+        toolbarState = .empty
+        accessoryToolbar.apply(state: .empty)
+        uninstallOutsideTapRecognizer()
+        refreshSystemAssistantToolbarIfNeeded()
+    }
+
+    func setEditorId(_ id: UInt64) {
+        let previousEditorId = richTextView.editorId
+        if id != 0 && NativeEditorViewRegistry.shared.isDestroyed(editorId: id) {
+            if previousEditorId == id {
+                handleEditorDestroyed(id)
+            } else {
+                setEditorId(0)
+            }
+            return
+        }
+        guard previousEditorId != id else {
+            if id != 0 {
+                if !NativeEditorViewRegistry.shared.register(editorId: id, view: self) {
+                    handleEditorDestroyed(id)
+                } else {
+                    ensureAutonomousErrorBinding()
+                }
+            }
+            return
+        }
+        if previousEditorId != id {
+            richTextView.textView.discardTransientNativeInputForEditorRebind()
+            let releasedNativeOwner = ownsNativeBinding(editorId: previousEditorId)
+            clearAutonomousErrorBinding()
+            NativeEditorViewRegistry.shared.unregister(editorId: previousEditorId, view: self)
+            if releasedNativeOwner {
+                NativeEditorViewRegistry.shared.nativeOwnerReleased(
+                    editorId: previousEditorId,
+                    by: self
+                )
+            }
+            clearPendingEditorUpdateRetries()
+            clearPendingViewCommandUpdateRetry()
+            clearPendingEditableRetry()
+            clearPendingThemeRetry()
+            clearPendingAtomsRetry()
+            clearPendingAccessoryRetry()
+            clearPendingMentionSuggestionRetry()
+        }
+        var initialBindUpdateJSON: String?
+        if id != 0 {
+            guard NativeEditorViewRegistry.shared.register(editorId: id, view: self) else {
+                handleEditorDestroyed(id)
+                return
+            }
+            bindAutonomousError(adapter: EditorV2Registry.adapter(forLegacyId: id), editorId: id)
+            initialBindUpdateJSON = EditorV2Registry.adapter(forLegacyId: id)?.initialUpdateJSON()
+        }
+        // Bind the editor with the same adopted snapshot used for toolbar
+        // state. The text view must not perform an independent state read.
+        imageLoadOwner.withCurrent {
+            richTextView.bindEditor(id: id, initialUpdateJSON: initialBindUpdateJSON)
+        }
+        if id != 0 {
+            richTextView.emitAtomContentWidthIfAvailable(force: true)
+        }
+        if id != 0 {
+            if let initialBindUpdateJSON,
+               let state = NativeToolbarState(updateJSON: initialBindUpdateJSON) {
+                toolbarState = state
+                accessoryToolbar.apply(state: state)
+            } else {
+                toolbarState = .empty
+                accessoryToolbar.apply(state: .empty)
+            }
+        } else {
+            toolbarState = .empty
+            accessoryToolbar.apply(state: .empty)
+        }
+        if desiredThemeJSON != lastThemeJSON {
+            setThemeJson(desiredThemeJSON)
+        }
+        if desiredAtomsJSON != lastAtomsJSON {
+            setAtomsJson(desiredAtomsJSON)
+        }
+        refreshSystemAssistantToolbarIfNeeded()
+        refreshMentionQuery()
+    }
+
+    func ownsNativeBinding(editorId: UInt64) -> Bool {
+        guard editorId != 0,
+              richTextView.editorId == editorId,
+              let adapter = EditorV2Registry.adapter(forLegacyId: editorId)
+        else { return false }
+        let autonomousOwner = autonomousErrorBindingAdapter === adapter
+            && autonomousErrorBindingToken.map { adapter.isNativeBindingOwner(token: $0) } == true
+        return autonomousOwner || richTextView.textView.ownsNativeBinding(adapter)
+    }
+
+    func claimNativeOwnershipAndCatchUp(editorId: UInt64) {
+        guard window != nil, richTextView.editorId == editorId else { return }
+        ensureAutonomousErrorBinding()
+        applyRemoteCommitRefresh()
+    }
+
+    func ensureAutonomousErrorBinding() {
+        let editorId = richTextView.editorId
+        guard editorId != 0,
+              let adapter = EditorV2Registry.adapter(forLegacyId: editorId)
+        else { return }
+        guard autonomousErrorBindingAdapter !== adapter
+            || autonomousErrorBindingEditorId != adapter.editorId
+            || autonomousErrorBindingToken.map({ adapter.isAutonomousErrorOwner(token: $0) }) != true
+        else { return }
+        clearAutonomousErrorBinding()
+        bindAutonomousError(adapter: adapter, editorId: editorId)
+    }
+
+    private func bindAutonomousError(adapter: EditorV2Adapter?, editorId: UInt64) {
+        guard let adapter,
+              let canonicalEditorId = v2CanonicalUInt64String(adapter.editorId),
+              canonicalEditorId == String(editorId),
+              !adapter.isDestroyed
+        else { return }
+        let token = UUID()
+        let generation = autonomousErrorBindingGeneration
+        autonomousErrorBindingAdapter = adapter
+        autonomousErrorBindingEditorId = canonicalEditorId
+        autonomousErrorBindingToken = token
+        adapter.bindAutonomousErrorOwner(token: token) { [weak self, weak adapter] error in
+            let enqueue = {
+                guard let self, let adapter else { return }
+                self.enqueueAutonomousError(
+                    error,
+                    from: adapter,
+                    editorId: canonicalEditorId,
+                    token: token,
+                    generation: generation
+                )
+            }
+            if Thread.isMainThread {
+                enqueue()
+            } else {
+                DispatchQueue.main.async(execute: enqueue)
+            }
+        }
+    }
+
+    func clearAutonomousErrorBinding() {
+        autonomousErrorBindingGeneration &+= 1
+        pendingAutonomousErrors.removeAll()
+        if let adapter = autonomousErrorBindingAdapter,
+           let token = autonomousErrorBindingToken {
+            adapter.clearAutonomousErrorOwner(token: token)
+        }
+        autonomousErrorBindingAdapter = nil
+        autonomousErrorBindingEditorId = nil
+        autonomousErrorBindingToken = nil
+    }
+
+    private func enqueueAutonomousError(
+        _ error: FfiError,
+        from adapter: EditorV2Adapter,
+        editorId: String,
+        token: UUID,
+        generation: UInt64
+    ) {
+        guard isLiveAutonomousErrorBinding(
+            adapter: adapter,
+            editorId: editorId,
+            token: token,
+            generation: generation
+        ) else { return }
+        let dispatchId = UUID()
+        pendingAutonomousErrors[dispatchId] = PendingAutonomousError(
+            adapter: adapter,
+            editorId: editorId,
+            token: token,
+            generation: generation,
+            error: error
+        )
+        DispatchQueue.main.async { [weak self] in
+            self?.dispatchAutonomousError(id: dispatchId)
+        }
+    }
+
+    private func dispatchAutonomousError(id: UUID) {
+        // Remove before invoking Expo/test code. Reentrant state changes or a
+        // duplicate callback cannot deliver this particular failure twice.
+        guard let pending = pendingAutonomousErrors.removeValue(forKey: id),
+              isLiveAutonomousErrorBinding(
+                adapter: pending.adapter,
+                editorId: pending.editorId,
+                token: pending.token,
+                generation: pending.generation
+              )
+        else { return }
+        let payload = NativeEditorExpoView.autonomousErrorEventPayload(
+            editorId: pending.editorId,
+            error: pending.error
+        )
+        if let onEditorErrorForTesting {
+            onEditorErrorForTesting(payload)
+        } else {
+            onEditorError(payload)
+        }
+    }
+
+    private func isLiveAutonomousErrorBinding(
+        adapter: EditorV2Adapter,
+        editorId: String,
+        token: UUID,
+        generation: UInt64
+    ) -> Bool {
+        guard autonomousErrorBindingGeneration == generation,
+              autonomousErrorBindingAdapter === adapter,
+              autonomousErrorBindingEditorId == editorId,
+              autonomousErrorBindingToken == token,
+              adapter.isAutonomousErrorOwner(token: token),
+              !adapter.isDestroyed,
+              let nativeEditorId = UInt64(editorId),
+              !NativeEditorViewRegistry.shared.isDestroyed(editorId: nativeEditorId),
+              EditorV2Registry.adapter(forLegacyId: nativeEditorId) === adapter
+        else { return false }
+        return true
+    }
+
+    private static func autonomousErrorEventPayload(editorId: String, error: FfiError) -> [String: Any] {
+        let errorRecord: [String: Any] = [
+            "domain": error.domain,
+            "code": error.code,
+            "message": error.message,
+            "requestId": error.requestId ?? NSNull(),
+            "operationIndex": error.operationIndex ?? NSNull(),
+            "limit": error.limit ?? NSNull(),
+            "actual": error.actual ?? NSNull(),
+            "detailsJson": error.detailsJson ?? NSNull()
+        ]
+        let payload: [String: Any] = [
+            "editorId": editorId,
+            "error": errorRecord
+        ]
+        return payload
+    }
+
+}

package/ios/NativeEditorExpoView+Diagnostics.swift

@@ -0,0 +1,66 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func setMentionQueryStateForTesting(_ state: MentionQueryState?) {
+        mentionQueryState = state
+    }
+
+    func currentMentionQueryStateForTesting(trigger: String) -> MentionQueryState? {
+        currentMentionQueryState(trigger: trigger)
+    }
+
+    func setMentionSuggestionsForTesting(_ suggestions: [NativeMentionSuggestion]) {
+        accessoryToolbar.setMentionSuggestions(
+            suggestions,
+            trigger: mentionQueryState?.trigger ?? "@"
+        )
+    }
+
+    func isShowingMentionSuggestionsForTesting() -> Bool {
+        accessoryToolbar.isShowingMentionSuggestions
+    }
+
+    func lastAddonEventJSONForTesting() -> String? {
+        lastAddonEventJSONForTestingValue
+    }
+
+    func triggerMentionSuggestionTapForTesting(at index: Int) {
+        accessoryToolbar.triggerMentionSuggestionTapForTesting(at: index)
+    }
+
+    func inputAccessoryViewForTesting() -> UIView? {
+        richTextView.textView.inputAccessoryView
+    }
+
+    func isUsingAccessoryToolbarForTesting() -> Bool {
+        richTextView.textView.inputAccessoryView === accessoryToolbar
+    }
+
+    func isUsingAccessoryPlaceholderForTesting() -> Bool {
+        richTextView.textView.inputAccessoryView === accessoryPlaceholder
+    }
+
+    func markRecentToolbarTouchForTesting() {
+        markRecentToolbarTouch()
+    }
+
+    func shouldPreserveFocusAfterToolbarTouchForTesting() -> Bool {
+        shouldPreserveFocusAfterToolbarTouch()
+    }
+
+    func consumeToolbarFocusPreservationForTesting() -> Bool {
+        consumeToolbarFocusPreservationForBlur()
+    }
+
+    func prepareOutsideTapForFocusHandlingForTesting(
+        locationInWindow: CGPoint,
+        touchedView: UIView? = nil
+    ) -> Bool {
+        prepareOutsideTapForFocusHandling(
+            locationInWindow: locationInWindow,
+            touchedView: touchedView
+        )
+    }
+
+}

package/ios/NativeEditorExpoView+Events.swift

@@ -0,0 +1,131 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func editorTextView(
+        _ textView: EditorTextView,
+        didEndExternalTextComposition resultJSON: String
+    ) {
+        schedulePendingAtomsWakeIfNeeded()
+        dispatchExternalTextCompositionEnd(resultJSON)
+    }
+
+    func dispatchExternalTextCompositionEnd(_ resultJSON: String) {
+        let payload: [String: Any] = [
+            "editorId": String(richTextView.editorId),
+            "resultJson": resultJSON
+        ]
+        if let onExternalTextCompositionEndForTesting {
+            onExternalTextCompositionEndForTesting(payload)
+        } else {
+            onExternalTextCompositionEnd(payload)
+        }
+    }
+
+    func editorTextView(_ textView: EditorTextView, selectionDidChange anchor: UInt32, head: UInt32) {
+        let originatingEditorId = textView.editorId
+        let stateJSON = refreshToolbarStateFromEditorSelection()
+        refreshSystemAssistantToolbarIfNeeded()
+        refreshMentionQuery()
+        richTextView.refreshRemoteSelections()
+        var event: [String: Any] = ["anchor": Int(anchor), "head": Int(head)]
+        if let stateJSON {
+            event["stateJson"] = stateJSON
+        }
+        guard let scopedEvent = Self.editorScopedEventPayload(
+            event,
+            originatingEditorId: originatingEditorId
+        ) else { return }
+        onSelectionChange(scopedEvent)
+    }
+
+    func editorTextView(_ textView: EditorTextView, didReceiveUpdate updateJSON: String) {
+        schedulePendingAtomsWakeIfNeeded()
+        if let revision = renderRevision(fromUpdateJSON: updateJSON) {
+            renderedRevision = revision
+        }
+        // Capture both fields from the same committed atomic update before
+        // any view work can cause a rebind. The event must never relabel A's
+        // update as B merely because the host changes editorId afterwards.
+        let nativeCommitEvent = Self.nativeCommitEventPayload(
+            originatingEditorId: String(textView.editorId),
+            updateJSON: updateJSON
+        )
+        if let state = NativeToolbarState(updateJSON: updateJSON) {
+            toolbarState = state
+            accessoryToolbar.apply(state: state)
+            refreshSystemAssistantToolbarIfNeeded()
+        }
+        refreshMentionQuery()
+        richTextView.refreshRemoteSelections()
+        guard !isApplyingJSUpdate else { return }
+        guard let nativeCommitEvent else { return }
+        onEditorUpdate(nativeCommitEvent)
+    }
+
+    /// The canonical JS commit contract. `originatingEditorId` is captured
+    /// synchronously from the text view which applied `updateJSON`; it is not
+    /// read from the host view after asynchronous rebind work.
+    static func nativeCommitEventPayload(
+        originatingEditorId: String,
+        updateJSON: String
+    ) -> [String: Any]? {
+        guard let editorId = v2CanonicalUInt64String(originatingEditorId),
+              editorId != "0",
+              let nativeEditorId = UInt64(editorId),
+              let data = updateJSON.data(using: .utf8),
+              let update = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let rawRevision = update["documentVersion"] as? String,
+              let documentRevision = v2CanonicalUInt64String(rawRevision),
+              let revision = UInt64(documentRevision),
+              let atomicUpdateJSON = EditorV2Registry.adapter(forLegacyId: nativeEditorId)?
+              .atomicRenderJSON(matchingDocumentRevision: revision)
+        else {
+            return nil
+        }
+        return [
+            "editorId": editorId,
+            "documentRevision": documentRevision,
+            "updateJson": atomicUpdateJSON
+        ]
+    }
+
+    /// Every non-commit view event is labelled with the editor that produced
+    /// it, captured before refresh/rebind work can change the view binding.
+    static func editorScopedEventPayload(
+        _ payload: [String: Any],
+        originatingEditorId: UInt64
+    ) -> [String: Any]? {
+        guard originatingEditorId != 0,
+              let editorId = v2CanonicalUInt64String(String(originatingEditorId))
+        else {
+            return nil
+        }
+        var scopedPayload = payload
+        scopedPayload["editorId"] = editorId
+        return scopedPayload
+    }
+
+    @discardableResult
+    private func refreshToolbarStateFromEditorSelection() -> String? {
+        guard richTextView.editorId != 0 else { return nil }
+        let stateJSON = EditorV2Shadow.getSelectionState(id: richTextView.editorId)
+        guard let state = NativeToolbarState(updateJSON: stateJSON) else { return nil }
+        toolbarState = state
+        accessoryToolbar.apply(state: state)
+        return stateJSON
+    }
+
+    func configureAccessoryToolbar() {
+        accessoryToolbar.onPressItem = { [weak self] item in
+            self?.handleToolbarItemPress(item)
+        }
+        accessoryToolbar.onSelectMentionSuggestion = { [weak self] suggestion in
+            self?.insertMentionSuggestion(suggestion)
+        }
+        accessoryToolbar.setItems(toolbarItems)
+        accessoryToolbar.apply(state: toolbarState)
+        updateAccessoryToolbarVisibility()
+    }
+
+}