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

package/ios/NativeEditorExpoView+Mentions.swift

@@ -0,0 +1,288 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func refreshMentionQuery() {
+        guard richTextView.editorId != 0,
+              richTextView.textView.isFirstResponder,
+              let mentions = addons.mentions
+        else {
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+        guard prepareForInputAccessoryMutationOrRetry(.refreshMentionQuery) else { return }
+
+        guard let queryState = currentMentionQueryState(trigger: mentions.trigger) else {
+            emitMentionQueryChange(query: "", trigger: mentions.trigger, anchor: 0, head: 0, isActive: false)
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+
+        let suggestions = filteredMentionSuggestions(for: queryState, config: mentions)
+        mentionQueryState = queryState
+        accessoryToolbar.apply(mentionTheme: richTextView.textView.theme?.mentions ?? mentions.theme)
+        let didChangeToolbarHeight = accessoryToolbar.setMentionSuggestions(
+            suggestions,
+            trigger: mentions.trigger
+        )
+        refreshSystemAssistantToolbarIfNeeded()
+        if didChangeToolbarHeight,
+           richTextView.textView.isFirstResponder,
+           richTextView.textView.inputAccessoryView === accessoryToolbar {
+            richTextView.textView.reloadInputViews()
+        }
+        markAccessoryMutationSucceeded(.refreshMentionQuery)
+        emitMentionQueryChange(
+            query: queryState.query,
+            trigger: queryState.trigger,
+            anchor: queryState.anchor,
+            head: queryState.head,
+            isActive: true
+        )
+    }
+
+    func clearMentionQueryStateAndHidePopover() {
+        guard prepareForInputAccessoryMutationOrRetry(.clearMentionQueryState) else { return }
+        mentionQueryState = nil
+        let didChangeToolbarHeight = accessoryToolbar.setMentionSuggestions([])
+        refreshSystemAssistantToolbarIfNeeded()
+        if didChangeToolbarHeight,
+           richTextView.textView.isFirstResponder,
+           richTextView.textView.inputAccessoryView === accessoryToolbar {
+            richTextView.textView.reloadInputViews()
+        }
+        markAccessoryMutationSucceeded(.clearMentionQueryState)
+    }
+
+    private func emitMentionQueryChange(
+        query: String,
+        trigger: String,
+        anchor: UInt32,
+        head: UInt32,
+        isActive: Bool
+    ) {
+        let payload: [String: Any] = [
+            "type": "mentionsQueryChange",
+            "query": query,
+            "trigger": trigger,
+            "range": [
+                "anchor": Int(anchor),
+                "head": Int(head)
+            ],
+            "isActive": isActive
+        ]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return
+        }
+        guard json != lastMentionEventJSON else { return }
+        lastMentionEventJSON = json
+        dispatchAddonEvent(json)
+    }
+
+    func resolvedMentionAttrs(
+        trigger: String,
+        suggestion: NativeMentionSuggestion
+    ) -> [String: Any] {
+        var attrs = suggestion.attrs
+        if attrs["label"] == nil {
+            attrs["label"] = suggestion.label
+        }
+        if attrs["mentionSuggestionChar"] == nil {
+            attrs["mentionSuggestionChar"] = trigger
+        }
+        return attrs
+    }
+
+    func emitMentionSelect(
+        trigger: String,
+        suggestion: NativeMentionSuggestion,
+        attrs: [String: Any]
+    ) {
+        let payload: [String: Any] = [
+            "type": "mentionsSelect",
+            "trigger": trigger,
+            "suggestionKey": suggestion.key,
+            "attrs": attrs
+        ]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return
+        }
+        dispatchAddonEvent(json)
+    }
+
+    func emitMentionSelectRequest(
+        trigger: String,
+        suggestion: NativeMentionSuggestion,
+        attrs: [String: Any],
+        range: MentionQueryState,
+        preflightUpdateJSON: String? = nil
+    ) {
+        var payload: [String: Any] = [
+            "type": "mentionsSelectRequest",
+            "trigger": trigger,
+            "suggestionKey": suggestion.key,
+            "attrs": attrs,
+            "range": [
+                "anchor": Int(range.anchor),
+                "head": Int(range.head)
+            ]
+        ]
+        if let preflightUpdateJSON {
+            payload["updateJson"] = preflightUpdateJSON
+        }
+        if let documentVersion = documentVersion(fromUpdateJSON: preflightUpdateJSON) {
+            payload["documentVersion"] = documentVersion
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return
+        }
+        dispatchAddonEvent(json)
+    }
+
+    private func dispatchAddonEvent(_ json: String) {
+        let originatingEditorId = richTextView.editorId
+        lastAddonEventJSONForTestingValue = json
+        guard let event = Self.editorScopedEventPayload(
+            ["eventJson": json],
+            originatingEditorId: originatingEditorId
+        ) else { return }
+        onAddonEvent(event)
+    }
+
+    func isSupersededEditorUpdate(_ updateJSON: String) -> Bool {
+        guard let rendered = renderedRevision,
+              let incoming = renderRevision(fromUpdateJSON: updateJSON)
+        else {
+            return false
+        }
+        if incoming.document != rendered.document {
+            return incoming.document < rendered.document
+        }
+        return incoming.state < rendered.state
+    }
+
+    func renderRevision(
+        fromUpdateJSON updateJSON: String
+    ) -> (document: UInt64, state: UInt64)? {
+        guard let data = updateJSON.data(using: .utf8),
+              let raw = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let document = (raw["documentVersion"] as? String)
+              .flatMap(v2CanonicalUInt64String)
+              .flatMap(UInt64.init),
+              let state = (raw["stateRevision"] as? String)
+              .flatMap(v2CanonicalUInt64String)
+              .flatMap(UInt64.init)
+        else {
+            return nil
+        }
+        return (document: document, state: state)
+    }
+
+    func documentVersion(fromUpdateJSON updateJSON: String?) -> String? {
+        guard let updateJSON,
+              let data = updateJSON.data(using: .utf8),
+              let raw = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return (raw["documentVersion"] as? String).flatMap(v2CanonicalUInt64String)
+    }
+
+    func filteredMentionSuggestions(
+        for queryState: MentionQueryState,
+        config: NativeMentionsAddonConfig
+    ) -> [NativeMentionSuggestion] {
+        let query = queryState.query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard !query.isEmpty else {
+            return config.suggestions
+        }
+
+        return config.suggestions.filter { suggestion in
+            suggestion.title.lowercased().contains(query)
+                || suggestion.label.lowercased().contains(query)
+                || (suggestion.subtitle?.lowercased().contains(query) ?? false)
+        }
+    }
+
+    func currentMentionQueryState(trigger: String) -> MentionQueryState? {
+        guard let selectedTextRange = richTextView.textView.selectedTextRange,
+              selectedTextRange.isEmpty
+        else {
+            return nil
+        }
+
+        let currentText = richTextView.textView.text ?? ""
+        let cursorUtf16Offset = richTextView.textView.offset(
+            from: richTextView.textView.beginningOfDocument,
+            to: selectedTextRange.start
+        )
+        let visibleCursorScalar = PositionBridge.utf16OffsetToScalar(
+            cursorUtf16Offset,
+            in: currentText
+        )
+
+        guard let visibleQueryState = resolveMentionQueryState(
+            in: currentText,
+            cursorScalar: visibleCursorScalar,
+            trigger: trigger,
+            isCaretInsideMention: isCaretInsideMention(
+                cursorScalar: PositionBridge.textViewToScalar(
+                    selectedTextRange.start,
+                    in: richTextView.textView
+                )
+            )
+        ) else {
+            return nil
+        }
+
+        let anchorUtf16Offset = PositionBridge.scalarToUtf16Offset(
+            visibleQueryState.anchor,
+            in: currentText
+        )
+        let headUtf16Offset = PositionBridge.scalarToUtf16Offset(
+            visibleQueryState.head,
+            in: currentText
+        )
+
+        return MentionQueryState(
+            query: visibleQueryState.query,
+            trigger: visibleQueryState.trigger,
+            anchor: PositionBridge.utf16OffsetToScalar(
+                anchorUtf16Offset,
+                in: richTextView.textView
+            ),
+            head: PositionBridge.utf16OffsetToScalar(
+                headUtf16Offset,
+                in: richTextView.textView
+            )
+        )
+    }
+
+    private func isCaretInsideMention(cursorScalar: UInt32) -> Bool {
+        let utf16Offset = PositionBridge.scalarToUtf16Offset(
+            cursorScalar,
+            in: richTextView.textView.text ?? ""
+        )
+        let textStorage = richTextView.textView.textStorage
+        guard textStorage.length > 0 else { return false }
+        let candidateOffsets = [
+            min(max(utf16Offset, 0), max(textStorage.length - 1, 0)),
+            min(max(utf16Offset - 1, 0), max(textStorage.length - 1, 0))
+        ]
+
+        for offset in candidateOffsets where offset >= 0 && offset < textStorage.length {
+            if let nodeType = textStorage.attribute(RenderBridgeAttributes.voidNodeType, at: offset, effectiveRange: nil) as? String,
+               nodeType == "mention" {
+                return true
+            }
+        }
+        return false
+    }
+
+}

package/ios/NativeEditorExpoView+Properties.swift

@@ -0,0 +1,300 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func setThemeJson(_ themeJson: String?) {
+        desiredThemeJSON = themeJson
+        guard lastThemeJSON != themeJson else {
+            clearPendingThemeRetry()
+            return
+        }
+        let theme = EditorTheme.from(json: themeJson)
+        guard imageLoadOwner.withCurrent({ richTextView.applyTheme(theme) }) else {
+            scheduleThemeRetry(themeJson)
+            return
+        }
+        lastThemeJSON = themeJson
+        clearPendingThemeRetry()
+        accessoryToolbar.apply(theme: theme?.toolbar)
+        accessoryToolbar.apply(mentionTheme: theme?.mentions ?? addons.mentions?.theme)
+        refreshSystemAssistantToolbarIfNeeded()
+        if richTextView.textView.isFirstResponder,
+           richTextView.textView.inputAccessoryView === accessoryToolbar || shouldUseSystemAssistantToolbar {
+            reloadInputViewsAfterPreparingOrRetry()
+        }
+    }
+
+    func hasActiveMentionQueryForCurrentAddons() -> Bool {
+        guard richTextView.editorId != 0,
+              richTextView.textView.isFirstResponder,
+              let mentions = addons.mentions
+        else {
+            return false
+        }
+        return currentMentionQueryState(trigger: mentions.trigger) != nil
+    }
+
+    func setAddonsJson(_ addonsJson: String?) {
+        guard lastAddonsJSON != addonsJson else { return }
+        lastAddonsJSON = addonsJson
+        addons = NativeEditorAddons.from(json: addonsJson)
+        richTextView.textView.onCodeHighlightingError = { [weak self] error in
+            self?.onEditorError(["domain": "addon", "code": "CODE_HIGHLIGHTING_FAILED", "message": error.localizedDescription])
+        }
+        richTextView.textView.codeHighlighting = addons.codeHighlighting
+        accessoryToolbar.apply(mentionTheme: richTextView.textView.theme?.mentions ?? addons.mentions?.theme)
+        refreshMentionQuery()
+    }
+
+    func setAtomsJson(_ atomsJson: String?) {
+        if desiredAtomsJSON != atomsJson {
+            clearPendingAtomsRetry()
+        }
+        desiredAtomsJSON = atomsJson
+        guard lastAtomsJSON != atomsJson else {
+            clearPendingAtomsRetry()
+            return
+        }
+        let configuration = AtomRenderConfiguration.from(json: atomsJson)
+        guard !blockAtomConfigurationApplyForTesting,
+              richTextView.applyAtomRenderConfiguration(configuration)
+        else {
+            scheduleAtomsRetry(atomsJson)
+            return
+        }
+        lastAtomsJSON = atomsJson
+        clearPendingAtomsRetry()
+    }
+
+    func setImageLoadingPolicyJson(_ json: String?) {
+        let policy = ImageLoadingPolicy.from(json: json)
+        guard policy != imageLoadOwner.policy else { return }
+        imageLoadOwner.updatePolicy(policy)
+        richTextView.textView.imageLoadingPolicyDidChange()
+        guard richTextView.editorId != 0 else { return }
+        imageLoadOwner.withCurrent {
+            _ = richTextView.textView.applyUpdateJSON(
+                EditorV2Shadow.getCurrentState(id: richTextView.editorId),
+                notifyDelegate: false
+            )
+        }
+    }
+
+    func setRemoteSelectionsJson(_ remoteSelectionsJson: String?) {
+        guard lastRemoteSelectionsJSON != remoteSelectionsJson else { return }
+        lastRemoteSelectionsJSON = remoteSelectionsJson
+        richTextView.setRemoteSelections(RemoteSelectionDecoration.from(json: remoteSelectionsJson))
+    }
+
+    func setEditable(_ editable: Bool) {
+        if !editable, richTextView.textView.isEditable {
+            richTextView.textView.cancelExternalTextCompositionForLifecycleIfNeeded()
+        }
+        if !editable,
+           richTextView.textView.isEditable,
+           richTextView.editorId != 0,
+           !richTextView.textView.prepareForExternalEditorUpdate() {
+            scheduleEditableRetry(editable)
+            return
+        }
+        pendingEditableRetryValue = nil
+        pendingEditableRetryEditorId = nil
+        pendingEditableRetryScheduled = false
+        richTextView.textView.isEditable = editable
+        updateAccessoryToolbarVisibility()
+    }
+
+    func setAccessibilityLabel(_ label: String?) {
+        richTextView.textView.accessibilityLabel = label
+    }
+
+    func setAccessibilityHint(_ hint: String?) {
+        richTextView.textView.accessibilityHint = hint
+    }
+
+    private func scheduleEditableRetry(_ editable: Bool) {
+        pendingEditableRetryValue = editable
+        pendingEditableRetryEditorId = richTextView.editorId
+        guard !pendingEditableRetryScheduled else { return }
+        pendingEditableRetryScheduled = true
+        pendingEditableRetryGeneration &+= 1
+        let retryGeneration = pendingEditableRetryGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard retryGeneration == self.pendingEditableRetryGeneration else { return }
+            guard let pendingEditable = self.pendingEditableRetryValue else {
+                self.pendingEditableRetryScheduled = false
+                return
+            }
+            guard self.pendingEditableRetryEditorId == self.richTextView.editorId else {
+                self.clearPendingEditableRetry()
+                return
+            }
+            self.pendingEditableRetryValue = nil
+            self.pendingEditableRetryEditorId = nil
+            self.pendingEditableRetryScheduled = false
+            self.setEditable(pendingEditable)
+        }
+    }
+
+    func setAutoFocus(_ autoFocus: Bool) {
+        guard autoFocus, !didApplyAutoFocus else { return }
+        didApplyAutoFocus = true
+        focus()
+    }
+
+    func setAutoCapitalize(_ autoCapitalize: String?) {
+        richTextView.textView.setAutoCapitalize(autoCapitalize)
+    }
+
+    func setAutoCorrect(_ autoCorrect: Bool?) {
+        richTextView.textView.setAutoCorrect(autoCorrect)
+    }
+
+    func setKeyboardType(_ keyboardType: String?) {
+        richTextView.textView.setKeyboardType(keyboardType)
+    }
+
+    func setShowToolbar(_ showToolbar: Bool) {
+        showsToolbar = showToolbar
+        updateAccessoryToolbarVisibility()
+    }
+
+    func setToolbarPlacement(_ toolbarPlacement: String?) {
+        self.toolbarPlacement = toolbarPlacement == "inline" ? "inline" : "keyboard"
+        updateAccessoryToolbarVisibility()
+    }
+
+    func setHeightBehavior(_ rawHeightBehavior: String) {
+        let nextBehavior = EditorHeightBehavior(rawValue: rawHeightBehavior) ?? .fixed
+        guard nextBehavior != heightBehavior else { return }
+        heightBehavior = nextBehavior
+        if nextBehavior != .autoGrow {
+            cachedAutoGrowContentHeight = 0
+            publishAutoGrowStyleHeight(nil)
+        }
+        richTextView.heightBehavior = nextBehavior
+        invalidateIntrinsicContentSize()
+        setNeedsLayout()
+        if nextBehavior == .autoGrow {
+            emitContentHeightIfNeeded(force: true)
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.heightBehavior == .autoGrow else { return }
+                self.setNeedsLayout()
+                self.layoutIfNeeded()
+                let measuredHeight = self.richTextView.remeasureAutoGrowHeight()
+                guard measuredHeight > 0 else { return }
+                self.cachedAutoGrowContentHeight = measuredHeight
+                self.invalidateIntrinsicContentSize()
+                self.emitContentHeightIfNeeded(force: true, measuredHeight: measuredHeight)
+            }
+        }
+    }
+
+    func setAllowImageResizing(_ allowImageResizing: Bool) {
+        richTextView.allowImageResizing = allowImageResizing
+    }
+
+    func emitContentHeightIfNeeded(force: Bool = false, measuredHeight: CGFloat? = nil) {
+        let originatingEditorId = richTextView.editorId
+        guard heightBehavior == .autoGrow else { return }
+        let resolvedHeight = measuredHeight
+            ?? (cachedAutoGrowContentHeight > 0 ? cachedAutoGrowContentHeight : richTextView.intrinsicContentSize.height)
+        let contentHeight = ceil(resolvedHeight)
+        guard contentHeight > 0 else { return }
+        publishAutoGrowStyleHeight(contentHeight)
+        guard force || abs(contentHeight - lastEmittedContentHeight) > 0.5 else { return }
+        cachedAutoGrowContentHeight = contentHeight
+        lastEmittedContentHeight = contentHeight
+        guard let event = Self.editorScopedEventPayload(
+            ["contentHeight": contentHeight],
+            originatingEditorId: originatingEditorId
+        ) else { return }
+        onContentHeightChange(event)
+    }
+
+    func emitAtomLayout(width: CGFloat) {
+        guard let event = Self.editorScopedEventPayload(
+            [
+                "width": Double(width),
+                "positions": richTextView.atomLayoutPositions(),
+                "viewport": [
+                    "y": Double(richTextView.textView.contentOffset.y),
+                    "height": Double(richTextView.textView.bounds.height)
+                ]
+            ],
+            originatingEditorId: richTextView.editorId
+        ) else { return }
+        onAtomLayout(event)
+    }
+
+    static func atomKey(for view: UIView) -> String? {
+        let selector = NSSelectorFromString("nativeId")
+        let nativeId = view.responds(to: selector) ? view.value(forKey: "nativeId") as? String : nil
+        let identifier = nativeId ?? view.accessibilityIdentifier
+        let prefix = "prose-atom:"
+        guard let identifier,
+              identifier.hasPrefix(prefix),
+              identifier.count > prefix.count
+        else { return nil }
+        return String(identifier.dropFirst(prefix.count))
+    }
+
+    private func publishAutoGrowStyleHeight(_ height: CGFloat?) {
+        if let height {
+            if let lastPublishedAutoGrowHeight,
+               abs(height - lastPublishedAutoGrowHeight) <= Self.layoutEpsilon {
+                return
+            }
+            lastPublishedAutoGrowHeight = height
+        } else {
+            guard lastPublishedAutoGrowHeight != nil else { return }
+            lastPublishedAutoGrowHeight = nil
+        }
+        let selector = NSSelectorFromString("setStyleSize:height:")
+        guard responds(to: selector) else { return }
+        _ = perform(selector, with: nil, with: height.map { NSNumber(value: Double($0)) })
+    }
+
+    func setToolbarButtonsJson(_ toolbarButtonsJson: String?) {
+        guard lastToolbarItemsJSON != toolbarButtonsJson else { return }
+        lastToolbarItemsJSON = toolbarButtonsJson
+        toolbarItems = NativeToolbarItem.from(json: toolbarButtonsJson)
+        accessoryToolbar.setItems(toolbarItems)
+        refreshSystemAssistantToolbarIfNeeded()
+    }
+
+    func setToolbarFrameJson(_ toolbarFrameJson: String?) {
+        guard lastToolbarFrameJSON != toolbarFrameJson else { return }
+        lastToolbarFrameJSON = toolbarFrameJson
+        guard let toolbarFrameJson,
+              let data = toolbarFrameJson.data(using: .utf8),
+              let raw = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            toolbarFramesInWindow = []
+            return
+        }
+
+        if let frameDictionaries = raw["frames"] as? [[String: Any]] {
+            toolbarFramesInWindow = frameDictionaries.compactMap(Self.toolbarFrame(from:))
+            return
+        }
+
+        toolbarFramesInWindow = Self.toolbarFrame(from: raw).map { [$0] } ?? []
+    }
+
+    private static func toolbarFrame(from raw: [String: Any]) -> CGRect? {
+        guard let x = (raw["x"] as? NSNumber)?.doubleValue,
+              let y = (raw["y"] as? NSNumber)?.doubleValue,
+              let width = (raw["width"] as? NSNumber)?.doubleValue,
+              let height = (raw["height"] as? NSNumber)?.doubleValue,
+              width > 0,
+              height > 0
+        else {
+            return nil
+        }
+
+        return CGRect(x: x, y: y, width: width, height: height)
+    }
+
+}

package/ios/NativeEditorExpoView+Toolbar.swift

@@ -0,0 +1,86 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func updateAccessoryToolbarVisibility() {
+        guard prepareForInputAccessoryMutationOrRetry(.updateAccessoryToolbarVisibility) else { return }
+        refreshSystemAssistantToolbarIfNeeded()
+        let nextAccessoryView: UIView?
+        if showsToolbar &&
+            toolbarPlacement == "keyboard" &&
+            richTextView.textView.isEditable &&
+            !shouldUseSystemAssistantToolbar {
+            nextAccessoryView = accessoryToolbar
+        } else if richTextView.textView.isEditable && !shouldUseSystemAssistantToolbar {
+            nextAccessoryView = accessoryPlaceholder
+        } else {
+            nextAccessoryView = nil
+        }
+        if richTextView.textView.inputAccessoryView !== nextAccessoryView {
+            richTextView.textView.inputAccessoryView = nextAccessoryView
+            if richTextView.textView.isFirstResponder {
+                richTextView.textView.reloadInputViews()
+            }
+        }
+        markAccessoryMutationSucceeded(.updateAccessoryToolbarVisibility)
+    }
+
+    func refreshSystemAssistantToolbarIfNeeded() {
+        guard #available(iOS 26.0, *) else { return }
+
+        let assistantItem = richTextView.textView.inputAssistantItem
+        assistantItem.allowsHidingShortcuts = false
+        assistantItem.leadingBarButtonGroups = []
+        assistantItem.trailingBarButtonGroups = []
+    }
+
+    private func handleListToggle(_ listType: String) {
+        let isActive = toolbarState.nodes[listType] == true
+        richTextView.textView.performToolbarToggleList(listType, isActive: isActive)
+    }
+
+    func handleToolbarItemPress(_ item: NativeToolbarItem) {
+        let originatingEditorId = richTextView.editorId
+        switch item.type {
+        case .mark:
+            guard let mark = item.mark else { return }
+            richTextView.textView.performToolbarToggleMark(mark)
+        case .heading:
+            guard let level = item.headingLevel else { return }
+            richTextView.textView.performToolbarToggleHeading(level)
+        case .blockquote:
+            richTextView.textView.performToolbarToggleBlockquote()
+        case .list:
+            guard let listType = item.listType?.rawValue else { return }
+            handleListToggle(listType)
+        case .command:
+            switch item.command {
+            case .indentList:
+                richTextView.textView.performToolbarIndentListItem()
+            case .outdentList:
+                richTextView.textView.performToolbarOutdentListItem()
+            case .undo:
+                richTextView.textView.performToolbarUndo()
+            case .redo:
+                richTextView.textView.performToolbarRedo()
+            case .none:
+                break
+            }
+        case .node:
+            guard let nodeType = item.nodeType else { return }
+            richTextView.textView.performToolbarInsertNode(nodeType)
+        case .action:
+            guard let key = item.key else { return }
+            guard let event = Self.editorScopedEventPayload(
+                ["key": key],
+                originatingEditorId: originatingEditorId
+            ) else { return }
+            onToolbarAction(event)
+        case .group:
+            break
+        case .separator:
+            break
+        }
+    }
+
+}