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

package/ios/NativeEditorExpoView+Updates.swift

@@ -0,0 +1,312 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func setPendingEditorUpdateJson(_ editorUpdateJson: String?) {
+        lastEditorUpdateJSONProp = editorUpdateJson
+        pendingEditorUpdateJSON = editorUpdateJson
+        if editorUpdateJson == nil {
+            pendingEditorUpdateEditorId = nil
+        }
+    }
+
+    func setPendingEditorUpdateEditorId(_ editorUpdateEditorId: String?) {
+        guard let editorUpdateEditorId,
+              let canonicalEditorId = v2CanonicalUInt64String(editorUpdateEditorId),
+              canonicalEditorId != "0"
+        else {
+            pendingEditorUpdateEditorId = nil
+            return
+        }
+        pendingEditorUpdateEditorId = canonicalEditorId
+    }
+
+    func setPendingEditorUpdateRevision(_ editorUpdateRevision: Int) {
+        if editorUpdateRevision != 0, pendingEditorUpdateJSON == nil {
+            pendingEditorUpdateJSON = lastEditorUpdateJSONProp
+        }
+        pendingEditorUpdateRevision = editorUpdateRevision
+    }
+
+    func applyPendingEditorUpdateIfNeeded() {
+        guard pendingEditorUpdateRevision != 0 else { return }
+        guard pendingEditorUpdateRevision != appliedEditorUpdateRevision else { return }
+        let pendingRevision = pendingEditorUpdateRevision
+        guard let updateJSON = pendingEditorUpdateJSON else {
+            reportRejectedEditorUpdateEnvelope(
+                "external editor update JSON is missing",
+                fallbackClassification: "missingUpdateJSON"
+            )
+            consumePendingEditorUpdate(revision: pendingRevision)
+            return
+        }
+        switch applyEditorUpdateOutcome(updateJSON, sourceEditorId: pendingEditorUpdateEditorId, resetJSON: pendingEditorUpdateResetJSON) {
+        case .applied:
+            consumePendingEditorUpdate(revision: pendingRevision)
+        case .retryableDeferred:
+            schedulePendingEditorUpdateRetry()
+        case .rejected:
+            // Mark this prop revision consumed before discarding its envelope:
+            // OnViewDidUpdateProps can run again with the same values, but a
+            // permanent rejection must not report or retry a second time.
+            if let sourceEditorId = pendingEditorUpdateEditorId,
+               richTextView.editorId != 0,
+               sourceEditorId != String(richTextView.editorId) {
+                pendingEditorUpdateEditorId = nil
+            }
+            consumePendingEditorUpdate(revision: pendingRevision)
+        }
+    }
+
+    private func consumePendingEditorUpdate(revision: Int) {
+        appliedEditorUpdateRevision = revision
+        pendingEditorUpdateJSON = nil
+        pendingEditorUpdateRevision = 0
+        pendingEditorUpdateRetryScheduled = false
+        pendingEditorUpdateRetryEditorId = nil
+        pendingEditorUpdateRetryGeneration &+= 1
+    }
+
+    private func schedulePendingEditorUpdateRetry() {
+        guard !pendingEditorUpdateRetryScheduled else { return }
+        pendingEditorUpdateRetryEditorId = richTextView.editorId
+        pendingEditorUpdateRetryScheduled = true
+        pendingEditorUpdateRetryGeneration &+= 1
+        let retryGeneration = pendingEditorUpdateRetryGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard retryGeneration == self.pendingEditorUpdateRetryGeneration else {
+                return
+            }
+            guard self.pendingEditorUpdateRetryEditorId == self.richTextView.editorId else {
+                self.pendingEditorUpdateRetryScheduled = false
+                self.clearPendingEditorUpdateRetries()
+                return
+            }
+            self.pendingEditorUpdateRetryScheduled = false
+            self.pendingEditorUpdateRetryEditorId = nil
+            self.applyPendingEditorUpdateIfNeeded()
+        }
+    }
+
+    func beginExternalTextComposition(sessionId: String) -> String {
+        richTextView.textView.beginExternalTextComposition(sessionId: sessionId)
+    }
+
+    func updateExternalTextComposition(sessionId: String, text: String) -> String {
+        richTextView.textView.updateExternalTextComposition(sessionId: sessionId, text: text)
+    }
+
+    func commitExternalTextComposition(sessionId: String, finalText: String) -> String {
+        richTextView.textView.commitExternalTextComposition(
+            sessionId: sessionId,
+            finalText: finalText
+        )
+    }
+
+    func cancelExternalTextComposition(sessionId: String, cause: String) -> String {
+        richTextView.textView.cancelExternalTextComposition(sessionId: sessionId, cause: cause)
+    }
+
+    private func reportRejectedEditorUpdateEnvelope(
+        _ message: String,
+        fallbackClassification: String
+    ) {
+        if let adapter = EditorV2Registry.adapter(forLegacyId: richTextView.editorId) {
+            adapter.rejectExternalRenderEnvelope(message)
+        } else {
+            editorUpdateInternalRejections.append(
+                "boundary/FFI_RESULT_INVALID/\(fallbackClassification)"
+            )
+        }
+    }
+
+    func applyRemoteCommitRefresh() {
+        // Preparing an external update commits a live composition. The commit
+        // re-bases the adapter itself, so leave the half-typed word alone.
+        guard !richTextView.textView.hasPendingCompositionForExternalRefresh else { return }
+        let boundEditorId = richTextView.editorId
+        guard boundEditorId != 0,
+              let adapter = EditorV2Registry.adapter(forLegacyId: boundEditorId),
+              !adapter.isDestroyed
+        else {
+            return
+        }
+        let autonomousOwner = autonomousErrorBindingAdapter === adapter
+            && autonomousErrorBindingToken.map { adapter.isNativeBindingOwner(token: $0) } == true
+        guard autonomousOwner || richTextView.textView.ownsNativeBinding(adapter) else { return }
+        let preflight = richTextView.textView.prepareForExternalEditorUpdateResult()
+        guard preflight.ready else { return }
+        guard let update = preflight.adoptedUpdateJSON
+            ?? adapter.refreshFromRustState(mirrorSelection: nil)
+        else {
+            return
+        }
+        if !richTextView.textView.applyUpdateJSON(update),
+           let recovery = adapter.recoverNativeRender() {
+            richTextView.textView.applyUpdateJSON(recovery)
+        }
+    }
+
+    private func applyEditorUpdateOutcome(
+        _ updateJson: String,
+        sourceEditorId: String?,
+        resetJSON: String? = nil
+    ) -> EditorUpdateApplyOutcome {
+        let boundEditorId = richTextView.editorId
+        guard boundEditorId != 0 else {
+            reportRejectedEditorUpdateEnvelope(
+                "external editor update has no bound adapter",
+                fallbackClassification: "missingAdapter"
+            )
+            return .rejected
+        }
+        guard let sourceEditorId else {
+            reportRejectedEditorUpdateEnvelope(
+                "external editor update source id is missing or malformed",
+                fallbackClassification: "malformedSourceEditorId"
+            )
+            return .rejected
+        }
+        guard sourceEditorId == String(boundEditorId) else {
+            reportRejectedEditorUpdateEnvelope(
+                "external editor update source does not match the bound canonical editor id",
+                fallbackClassification: "sourceEditorMismatch"
+            )
+            return .rejected
+        }
+        guard let adapter = EditorV2Registry.adapter(forLegacyId: boundEditorId) else {
+            reportRejectedEditorUpdateEnvelope(
+                "external editor update adapter is missing",
+                fallbackClassification: "missingAdapter"
+            )
+            return .rejected
+        }
+        guard !adapter.isDestroyed else {
+            adapter.rejectExternalRenderEnvelope("external editor update adapter is destroyed")
+            return .rejected
+        }
+        // A malformed external envelope is permanent, even if UIKit is in a
+        // transient composition that would otherwise make application
+        // retryable. Classify it before entering composition preflight.
+        guard adapter.validateExternalRender(updateJson) else {
+            return .rejected
+        }
+        if let resetJSON {
+            guard adapter.validateExternalReset(resetJSON) else { return .rejected }
+            isApplyingJSUpdate = true
+            defer { isApplyingJSUpdate = false }
+            richTextView.textView.discardTransientNativeInputForEditorReset()
+            guard let update = adapter.adoptExternalReset(updateJson, resetJSON: resetJSON) else {
+                return .rejected
+            }
+            clearPendingViewCommandUpdateRetry()
+            let applied = imageLoadOwner.withCurrent {
+                richTextView.textView.applyUpdateJSON(update)
+            }
+            if applied, renderRevision(fromUpdateJSON: update)?.document != renderRevision(fromUpdateJSON: updateJson)?.document {
+                isApplyingJSUpdate = false
+                editorTextView(richTextView.textView, didReceiveUpdate: update)
+            }
+            return applied ? .applied : .rejected
+        }
+        if isSupersededEditorUpdate(updateJson) {
+            return .applied
+        }
+        let preflight = richTextView.textView.prepareForExternalEditorUpdateResult()
+        guard preflight.ready else {
+            return .retryableDeferred
+        }
+        if preflight.adoptedUpdateJSON != nil {
+            return .applied
+        }
+        let adoptedUpdateJSON = adapter.adoptExternalRender(updateJson)
+        guard let adoptedUpdateJSON else {
+            // The adapter owns strict-parser and destroyed-race reporting.
+            // Do not add a second view-side record for the same rejection.
+            return .rejected
+        }
+        isApplyingJSUpdate = true
+        defer { isApplyingJSUpdate = false }
+        imageLoadOwner.withCurrent {
+            // The adapter cache and the payload are paired by the same
+            // editor-scoped call above; do not let the view display a render
+            // whose revision has not already been adopted for native input.
+            _ = richTextView.textView.applyUpdateJSON(adoptedUpdateJSON)
+        }
+        return .applied
+    }
+
+    /// Apply an editor update from JS. Sets the echo-suppression flag so the
+    /// resulting delegate callback is NOT re-dispatched back to JS.
+    @discardableResult
+    func applyEditorUpdate(_ updateJson: String) -> Bool {
+        let sourceEditorId = richTextView.editorId == 0 ? nil : String(richTextView.editorId)
+        switch applyEditorUpdateOutcome(updateJson, sourceEditorId: sourceEditorId) {
+        case .applied:
+            return true
+        case .retryableDeferred:
+            scheduleViewCommandUpdateRetry(updateJson, sourceEditorId: sourceEditorId)
+            return false
+        case .rejected:
+            return false
+        }
+    }
+
+    private func scheduleViewCommandUpdateRetry(_ updateJson: String, sourceEditorId: String?) {
+        pendingViewCommandUpdateJSON = updateJson
+        pendingViewCommandUpdateEditorId = richTextView.editorId
+        guard !pendingViewCommandUpdateRetryScheduled else { return }
+        pendingViewCommandUpdateRetryScheduled = true
+        pendingViewCommandUpdateRetryGeneration &+= 1
+        let retryGeneration = pendingViewCommandUpdateRetryGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard retryGeneration == self.pendingViewCommandUpdateRetryGeneration else {
+                return
+            }
+            guard self.pendingViewCommandUpdateJSON != nil else {
+                self.pendingViewCommandUpdateRetryScheduled = false
+                return
+            }
+            guard self.pendingViewCommandUpdateEditorId == self.richTextView.editorId else {
+                self.pendingViewCommandUpdateJSON = nil
+                self.pendingViewCommandUpdateEditorId = nil
+                self.pendingViewCommandUpdateRetryScheduled = false
+                return
+            }
+            guard self.richTextView.editorId != 0 else {
+                self.pendingViewCommandUpdateJSON = nil
+                self.pendingViewCommandUpdateEditorId = nil
+                self.pendingViewCommandUpdateRetryScheduled = false
+                return
+            }
+            let updateJSON = self.pendingViewCommandUpdateJSON
+            self.pendingViewCommandUpdateJSON = nil
+            self.pendingViewCommandUpdateEditorId = nil
+            self.pendingViewCommandUpdateRetryScheduled = false
+            guard let updateJSON else { return }
+            switch self.applyEditorUpdateOutcome(
+                updateJSON,
+                sourceEditorId: sourceEditorId
+            ) {
+            case .applied, .rejected:
+                return
+            case .retryableDeferred:
+                self.scheduleViewCommandUpdateRetry(updateJSON, sourceEditorId: sourceEditorId)
+            }
+        }
+    }
+
+    func prepareForEditorCommandJSON() -> String {
+        isApplyingJSUpdate = true
+        defer { isApplyingJSUpdate = false }
+        let preparation = richTextView.textView.prepareForExternalEditorCommand()
+        return NativeEditorViewRegistry.commandPreparationJSON(
+            ready: preparation.ready,
+            updateJSON: preparation.updateJSON,
+            blockedReason: preparation.blockedReason
+        )
+    }
+
+}

package/ios/NativeEditorExpoView.swift

@@ -0,0 +1,349 @@
+import ExpoModulesCore
+import UIKit
+
+final class PendingJSONRetry {
+    struct Token {
+        let generation: UInt64
+        let attempt: Int
+    }
+
+    var json: String?
+    var editorId: UInt64?
+    private var scheduled = false
+    var generation: UInt64 = 0
+    private(set) var attempts = 0
+
+    func clear() {
+        json = nil
+        editorId = nil
+        scheduled = false
+        attempts = 0
+        generation &+= 1
+    }
+
+    func schedule(
+        json: String?,
+        editorId: UInt64,
+        maxAttempts: Int?
+    ) -> Token? {
+        self.json = json
+        self.editorId = editorId
+        guard !scheduled else { return nil }
+        if let maxAttempts, attempts >= maxAttempts { return nil }
+        attempts += 1
+        scheduled = true
+        generation &+= 1
+        return Token(generation: generation, attempt: attempts)
+    }
+
+    func consume(_ token: Token) -> (json: String?, editorId: UInt64?)? {
+        guard token.generation == generation else { return nil }
+        let result = (json, editorId)
+        json = nil
+        editorId = nil
+        scheduled = false
+        return result
+    }
+}
+
+class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognizerDelegate {
+    static let layoutEpsilon: CGFloat = 0.5
+    static let nativeActionRetryDelay: TimeInterval = 0.016
+    static let maxPendingUpdateRetryAttempts = 5
+
+    // MARK: - Subviews
+
+    let richTextView: RichTextEditorView
+    let accessoryToolbar = EditorAccessoryToolbarView(
+        frame: .zero,
+        inputViewStyle: .keyboard
+    )
+    let accessoryPlaceholder = EditorAccessoryPlaceholderView(frame: .zero)
+    var toolbarFramesInWindow: [CGRect] = []
+    var lastToolbarTouchUptime: TimeInterval = -Double.infinity
+    var didApplyAutoFocus = false
+    var toolbarState = NativeToolbarState.empty
+    var toolbarItems: [NativeToolbarItem] = NativeToolbarItem.defaults
+    var showsToolbar = true
+    var toolbarPlacement = "keyboard"
+    var heightBehavior: EditorHeightBehavior = .fixed
+    private var lastAutoGrowWidth: CGFloat = 0
+    var lastPublishedAutoGrowHeight: CGFloat?
+    var addons = NativeEditorAddons(mentions: nil)
+    var mentionQueryState: MentionQueryState?
+    var lastMentionEventJSON: String?
+    var desiredThemeJSON: String?
+    var desiredAtomsJSON: String?
+    let imageLoadOwner = RenderImageLoadOwner(policy: .default)
+    var lastThemeJSON: String?
+    var lastAddonsJSON: String?
+    var lastAtomsJSON: String?
+    var lastRemoteSelectionsJSON: String?
+    var lastToolbarItemsJSON: String?
+    var lastToolbarFrameJSON: String?
+    private var isReparentingAtomChild = false
+    private var mountedReactChildren: [UIView] = []
+    private var mountedAtomKeys: [ObjectIdentifier: String] = [:]
+    var lastEditorUpdateJSONProp: String?
+    var pendingEditorUpdateResetJSON: String?
+    var pendingEditorUpdateJSON: String?
+    var pendingEditorUpdateEditorId: String?
+    var pendingEditorUpdateRevision = 0
+    var appliedEditorUpdateRevision = 0
+    var renderedRevision: (document: UInt64, state: UInt64)?
+    var pendingEditorUpdateRetryScheduled = false
+    var pendingEditorUpdateRetryEditorId: UInt64?
+    var pendingEditorUpdateRetryGeneration: UInt64 = 0
+    var editorUpdateInternalRejections: [String] = []
+    var pendingViewCommandUpdateJSON: String?
+    var pendingViewCommandUpdateEditorId: UInt64?
+    var pendingViewCommandUpdateRetryScheduled = false
+    var pendingViewCommandUpdateRetryGeneration: UInt64 = 0
+    var pendingEditableRetryValue: Bool?
+    var pendingEditableRetryEditorId: UInt64?
+    var pendingEditableRetryScheduled = false
+    var pendingEditableRetryGeneration: UInt64 = 0
+    let pendingThemeRetry = PendingJSONRetry()
+    let pendingAtomsRetry = PendingJSONRetry()
+    var pendingAtomsWakeScheduled = false
+    var atomsRetryAttemptsForTesting: Int { pendingAtomsRetry.attempts }
+    var blockAtomConfigurationApplyForTesting = false
+    var pendingAccessoryRetryActions: [PendingAccessoryRetryAction] = []
+    var invalidatedAccessoryRetryActions = Set<PendingAccessoryRetryAction>()
+    var pendingAccessoryRetryEditorId: UInt64?
+    var pendingAccessoryRetryScheduled = false
+    var pendingAccessoryRetryGeneration: UInt64 = 0
+    var pendingMentionSuggestionRetry: PendingMentionSuggestionRetry?
+    var pendingMentionSuggestionRetryScheduled = false
+    var pendingMentionSuggestionRetryGeneration: UInt64 = 0
+    lazy var outsideTapGestureRecognizer: UITapGestureRecognizer = {
+        let recognizer = UITapGestureRecognizer(
+            target: self,
+            action: #selector(handleOutsideTap(_:))
+        )
+        recognizer.cancelsTouchesInView = false
+        recognizer.delegate = self
+        return recognizer
+    }()
+    weak var gestureWindow: UIWindow?
+
+    /// Guard flag to suppress echo: when JS applies an update via the view
+    /// command, the resulting delegate callback must NOT be re-dispatched
+    /// back to JS.
+    var isApplyingJSUpdate = false
+
+    // MARK: - Event Dispatchers (wired by Expo Modules via reflection)
+
+    let onEditorUpdate = EventDispatcher()
+    let onSelectionChange = EventDispatcher()
+    let onFocusChange = EventDispatcher()
+    let onContentHeightChange = EventDispatcher()
+    let onAtomLayout = EventDispatcher()
+    let onToolbarAction = EventDispatcher()
+    let onAddonEvent = EventDispatcher()
+    let onEditorError = EventDispatcher()
+    let onExternalTextCompositionEnd = EventDispatcher()
+    /// Native integration tests capture the exact payload production sends to
+    /// Expo without assigning adapter callbacks directly.
+    var onEditorErrorForTesting: (([String: Any]) -> Void)?
+    var onExternalTextCompositionEndForTesting: (([String: Any]) -> Void)?
+    var autonomousErrorBindingAdapter: EditorV2Adapter?
+    var autonomousErrorBindingEditorId: String?
+    var autonomousErrorBindingToken: UUID?
+    var autonomousErrorBindingGeneration: UInt64 = 0
+    var pendingAutonomousErrors: [UUID: PendingAutonomousError] = [:]
+    var lastEmittedContentHeight: CGFloat = 0
+    var cachedAutoGrowContentHeight: CGFloat = 0
+    var lastAddonEventJSONForTestingValue: String?
+
+    enum EditorUpdateApplyOutcome {
+        case applied
+        case retryableDeferred
+        case rejected
+    }
+
+    enum PendingAccessoryRetryAction: Hashable {
+        case reloadInputViews
+        case refreshMentionQuery
+        case clearMentionQueryState
+        case updateAccessoryToolbarVisibility
+    }
+
+    struct PendingMentionSuggestionRetry {
+        let suggestionKey: String
+        let editorId: UInt64
+        let trigger: String
+        let query: String
+        let anchor: UInt32
+        let head: UInt32
+        let documentVersion: String?
+        let textSnapshot: String
+    }
+
+    struct PendingAutonomousError {
+        let adapter: EditorV2Adapter
+        let editorId: String
+        let token: UUID
+        let generation: UInt64
+        let error: FfiError
+    }
+
+    struct MentionRetryTextDiff {
+        let start: Int
+        let oldEnd: Int
+        let newEnd: Int
+    }
+
+    // MARK: - Initialization
+
+    required init(appContext: AppContext? = nil) {
+        richTextView = RichTextEditorView(frame: .zero)
+        super.init(appContext: appContext)
+        richTextView.imageLoadOwner = imageLoadOwner
+        richTextView.onHeightMayChange = { [weak self] measuredHeight in
+            guard let self, self.heightBehavior == .autoGrow else { return }
+            self.cachedAutoGrowContentHeight = measuredHeight
+            self.invalidateIntrinsicContentSize()
+            self.emitContentHeightIfNeeded(force: true, measuredHeight: measuredHeight)
+        }
+        richTextView.onAtomContentWidthChange = { [weak self] width in
+            self?.emitAtomLayout(width: width)
+        }
+        richTextView.textView.editorDelegate = self
+        richTextView.textView.onExternalUpdateReadinessMayChange = { [weak self] in
+            self?.schedulePendingAtomsWakeIfNeeded()
+        }
+        configureAccessoryToolbar()
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(textViewDidBeginEditing(_:)),
+            name: UITextView.textDidBeginEditingNotification,
+            object: richTextView.textView
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(textViewDidEndEditing(_:)),
+            name: UITextView.textDidEndEditingNotification,
+            object: richTextView.textView
+        )
+
+        addSubview(richTextView)
+    }
+
+    deinit {
+        richTextView.textView.editorDelegate = nil
+        richTextView.textView.onExternalUpdateReadinessMayChange = nil
+        if let resultJSON = richTextView.textView.discardTransientNativeInputForEditorRebind() {
+            dispatchExternalTextCompositionEnd(resultJSON)
+        }
+        let editorId = richTextView.editorId
+        let releasedNativeOwner = ownsNativeBinding(editorId: editorId)
+        clearAutonomousErrorBinding()
+        NativeEditorViewRegistry.shared.unregister(editorId: editorId, view: self)
+        if releasedNativeOwner {
+            NativeEditorViewRegistry.shared.nativeOwnerReleased(editorId: editorId, by: self)
+        }
+        imageLoadOwner.cancelAll()
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    // MARK: - Layout
+
+    override func mountChildComponentView(_ childComponentView: UIView, index: Int) {
+        let reactIndex = min(max(index, 0), mountedReactChildren.count)
+        mountedReactChildren.insert(childComponentView, at: reactIndex)
+        let atomKey = Self.atomKey(for: childComponentView)
+        if let atomKey {
+            mountedAtomKeys[ObjectIdentifier(childComponentView)] = atomKey
+            richTextView.mountAtomChild(childComponentView, atomKey: atomKey)
+        } else {
+            let nativeSubviewCount = subviews.filter { subview in
+                !mountedReactChildren.contains(where: { $0 === subview })
+            }.count
+            let directIndex = nativeSubviewCount + mountedReactChildren[..<reactIndex].filter {
+                mountedAtomKeys[ObjectIdentifier($0)] == nil
+            }.count
+            super.mountChildComponentView(childComponentView, index: directIndex)
+        }
+    }
+
+    override func unmountChildComponentView(_ childComponentView: UIView, index: Int) {
+        if let reactIndex = mountedReactChildren.firstIndex(where: { $0 === childComponentView }) {
+            mountedReactChildren.remove(at: reactIndex)
+        }
+        if mountedAtomKeys.removeValue(forKey: ObjectIdentifier(childComponentView)) != nil {
+            _ = richTextView.unmountAtomChild(childComponentView)
+            childComponentView.removeFromSuperview()
+            return
+        }
+        let directIndex = subviews.firstIndex(where: { $0 === childComponentView }) ?? index
+        super.unmountChildComponentView(childComponentView, index: directIndex)
+    }
+
+    override func didAddSubview(_ subview: UIView) {
+        super.didAddSubview(subview)
+        guard subview !== richTextView,
+              !isReparentingAtomChild,
+              let atomKey = Self.atomKey(for: subview)
+        else { return }
+        isReparentingAtomChild = true
+        richTextView.mountAtomChild(subview, atomKey: atomKey)
+        isReparentingAtomChild = false
+    }
+
+    override var intrinsicContentSize: CGSize {
+        guard heightBehavior == .autoGrow else {
+            return CGSize(width: UIView.noIntrinsicMetric, height: UIView.noIntrinsicMetric)
+        }
+        if cachedAutoGrowContentHeight > 0 {
+            return CGSize(width: UIView.noIntrinsicMetric, height: cachedAutoGrowContentHeight)
+        }
+        return richTextView.intrinsicContentSize
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        richTextView.frame = bounds
+        guard heightBehavior == .autoGrow else { return }
+        let currentWidth = bounds.width.rounded(.towardZero)
+        guard currentWidth != lastAutoGrowWidth else { return }
+        lastAutoGrowWidth = currentWidth
+        cachedAutoGrowContentHeight = 0
+        invalidateIntrinsicContentSize()
+        emitContentHeightIfNeeded(force: true)
+    }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window == nil {
+            let editorId = richTextView.editorId
+            let releasedNativeOwner = ownsNativeBinding(editorId: editorId)
+            clearAutonomousErrorBinding()
+            if releasedNativeOwner {
+                NativeEditorViewRegistry.shared.nativeOwnerReleased(editorId: editorId, by: self)
+            }
+        } else {
+            ensureAutonomousErrorBinding()
+            applyRemoteCommitRefresh()
+        }
+        if richTextView.textView.isFirstResponder {
+            installOutsideTapRecognizerIfNeeded()
+        } else {
+            uninstallOutsideTapRecognizer()
+        }
+    }
+
+    // MARK: - Autonomous adapter errors
+
+    var imageLoadingPolicy: ImageLoadingPolicy {
+        imageLoadOwner.policy
+    }
+
+    // MARK: - EditorTextViewDelegate
+
+    var shouldUseSystemAssistantToolbar: Bool {
+        false
+    }
+
+}