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

package/ios/NativeEditorViewRegistry.swift

@@ -0,0 +1,226 @@
+import UIKit
+
+enum NativeEditorDestroyReservationResult: Equatable {
+    case reserved
+    case alreadyInProgress
+    case unavailable
+}
+
+final class NativeEditorViewRegistry {
+    static let shared = NativeEditorViewRegistry()
+
+    private final class RegisteredView {
+        weak var view: NativeEditorExpoView?
+        let order: UInt64
+
+        init(view: NativeEditorExpoView, order: UInt64) {
+            self.view = view
+            self.order = order
+        }
+    }
+
+    private var viewsByEditorId: [UInt64: [RegisteredView]] = [:]
+    private var nextRegistrationOrder: UInt64 = 0
+    private var activeEditorIds: Set<UInt64> = []
+    private var destroyingEditorIds: Set<UInt64> = []
+    var onFinalizeDestroyForTesting: ((UInt64) throws -> Void)?
+
+    private init() {}
+
+    func markEditorCreated(editorId: UInt64) {
+        guard editorId != 0 else { return }
+        _ = performOnMain {
+            activeEditorIds.insert(editorId)
+        }
+    }
+
+    func rebaseAfterRemoteCommit(editorId: UInt64) {
+        guard editorId != 0 else { return }
+        DispatchQueue.main.async { [weak self] in
+            self?.applyRemoteCommitRefresh(editorId: editorId)
+        }
+    }
+
+    func applyRemoteCommitRefresh(editorId: UInt64) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        liveRegisteredViews(editorId: editorId).forEach { $0.view?.applyRemoteCommitRefresh() }
+    }
+
+    func isDestroyed(editorId: UInt64) -> Bool {
+        guard editorId != 0 else { return false }
+        return performOnMain {
+            if destroyingEditorIds.contains(editorId) { return true }
+            if activeEditorIds.contains(editorId) {
+                return false
+            }
+            return EditorV2Registry.adapter(forLegacyId: editorId) == nil
+        }
+    }
+
+    @discardableResult
+    func register(editorId: UInt64, view: NativeEditorExpoView) -> Bool {
+        guard editorId != 0 else { return false }
+        return performOnMain {
+            guard !destroyingEditorIds.contains(editorId) else { return false }
+            if !activeEditorIds.contains(editorId) {
+                guard EditorV2Registry.adapter(forLegacyId: editorId) != nil else {
+                    return false
+                }
+                activeEditorIds.insert(editorId)
+            }
+            var views = liveRegisteredViews(editorId: editorId)
+            guard !views.contains(where: { $0.view === view }) else { return true }
+            nextRegistrationOrder &+= 1
+            views.append(RegisteredView(view: view, order: nextRegistrationOrder))
+            viewsByEditorId[editorId] = views
+            return true
+        }
+    }
+
+    func unregister(editorId: UInt64, view: NativeEditorExpoView) {
+        guard editorId != 0 else { return }
+        performOnMain {
+            let views = liveRegisteredViews(editorId: editorId).filter { $0.view !== view }
+            if views.isEmpty {
+                viewsByEditorId.removeValue(forKey: editorId)
+            } else {
+                viewsByEditorId[editorId] = views
+            }
+        }
+    }
+
+    func nativeOwnerReleased(editorId: UInt64, by view: NativeEditorExpoView) {
+        guard editorId != 0 else { return }
+        performOnMain {
+            guard !destroyingEditorIds.contains(editorId) else { return }
+            let survivor = liveRegisteredViews(editorId: editorId)
+                .reversed()
+                .compactMap(\.view)
+                .first { $0 !== view && $0.window != nil }
+            survivor?.claimNativeOwnershipAndCatchUp(editorId: editorId)
+        }
+    }
+
+    func invalidateDestroyedEditor(editorId: UInt64) {
+        guard reserveDestroy(editorId: editorId) else { return }
+        finalizeDestroy(editorId: editorId)
+    }
+
+    /// Install the reversible, in-flight destroy gate before crossing the
+    /// FFI boundary. The active view state remains intact until finalization
+    /// so a retryable destroy can roll back without reconstructing bindings.
+    func acquireDestroyReservation(editorId: UInt64) -> NativeEditorDestroyReservationResult {
+        guard editorId != 0 else { return .unavailable }
+        return performOnMain {
+            guard !destroyingEditorIds.contains(editorId) else { return .alreadyInProgress }
+            guard activeEditorIds.contains(editorId)
+                || EditorV2Registry.adapter(forLegacyId: editorId) != nil
+            else {
+                return .unavailable
+            }
+            destroyingEditorIds.insert(editorId)
+            return .reserved
+        }
+    }
+
+    @discardableResult
+    func reserveDestroy(editorId: UInt64) -> Bool {
+        acquireDestroyReservation(editorId: editorId) == .reserved
+    }
+
+    func rollbackDestroy(editorId: UInt64) {
+        guard editorId != 0 else { return }
+        _ = performOnMain {
+            destroyingEditorIds.remove(editorId)
+        }
+    }
+
+    func isDestroyReserved(editorId: UInt64) -> Bool {
+        guard editorId != 0 else { return false }
+        return performOnMain {
+            destroyingEditorIds.contains(editorId)
+        }
+    }
+
+    func finalizeDestroy(editorId: UInt64) {
+        guard editorId != 0 else { return }
+        performOnMain {
+            guard destroyingEditorIds.contains(editorId) else { return }
+            invokeDestroyTestingHook(onFinalizeDestroyForTesting, editorId: editorId)
+            activeEditorIds.remove(editorId)
+            let views = viewsByEditorId.removeValue(forKey: editorId)?.compactMap(\.view) ?? []
+            views.forEach { $0.handleEditorDestroyed(editorId) }
+            destroyingEditorIds.remove(editorId)
+        }
+    }
+
+    func destroy(editorId: UInt64, operation: () -> Void) {
+        guard reserveDestroy(editorId: editorId) else { return }
+        operation()
+        finalizeDestroy(editorId: editorId)
+    }
+
+    func prepareForCommandJSON(editorId: UInt64) -> String {
+        let prepare = { () -> String in
+            if self.destroyingEditorIds.contains(editorId) {
+                return Self.commandPreparationJSON(ready: false, blockedReason: "destroying")
+            }
+            if !self.activeEditorIds.contains(editorId),
+               EditorV2Registry.adapter(forLegacyId: editorId) == nil {
+                return Self.commandPreparationJSON(ready: false, blockedReason: "destroyed")
+            }
+            let views = self.liveRegisteredViews(editorId: editorId).compactMap(\.view)
+            guard let view = views.reversed().first(where: {
+                $0.ownsNativeBinding(editorId: editorId)
+            }) ?? views.last else {
+                self.viewsByEditorId.removeValue(forKey: editorId)
+                return Self.commandPreparationJSON(ready: true)
+            }
+            return view.prepareForEditorCommandJSON()
+        }
+
+        return performOnMain(prepare)
+    }
+
+    private func liveRegisteredViews(editorId: UInt64) -> [RegisteredView] {
+        let views = viewsByEditorId[editorId]?.filter { $0.view != nil } ?? []
+        if views.isEmpty {
+            viewsByEditorId.removeValue(forKey: editorId)
+        } else {
+            viewsByEditorId[editorId] = views
+        }
+        return views.sorted { $0.order < $1.order }
+    }
+
+    static func commandPreparationJSON(
+        ready: Bool,
+        updateJSON: String? = nil,
+        blockedReason: String? = nil
+    ) -> String {
+        var payload: [String: Any] = ["ready": ready]
+        if let updateJSON {
+            payload["updateJSON"] = updateJSON
+        }
+        if let blockedReason {
+            payload["blockedReason"] = blockedReason
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            if let blockedReason {
+                return ready
+                    ? "{\"ready\":true,\"blockedReason\":\"\(blockedReason)\"}"
+                    : "{\"ready\":false,\"blockedReason\":\"\(blockedReason)\"}"
+            }
+            return ready ? "{\"ready\":true}" : "{\"ready\":false}"
+        }
+        return json
+    }
+
+    private func performOnMain<T>(_ work: () -> T) -> T {
+        if Thread.isMainThread {
+            return work()
+        }
+        return DispatchQueue.main.sync(execute: work)
+    }
+}

package/ios/NativeToolbar+ButtonStyle.swift

@@ -0,0 +1,214 @@
+import UIKit
+
+extension EditorAccessoryToolbarView {
+    func buttonState(
+        for item: NativeToolbarItem,
+        state: NativeToolbarState
+    ) -> (enabled: Bool, active: Bool) {
+        switch item.type {
+        case .mark:
+            let mark = item.mark ?? ""
+            return (
+                enabled: state.allowedMarks.contains(mark),
+                active: state.marks[mark] == true
+            )
+        case .heading:
+            let level = item.headingLevel ?? 0
+            let headingType = "h\(level)"
+            return (
+                enabled: state.commands["toggleHeading\(level)"] == true,
+                active: state.nodes[headingType] == true
+            )
+        case .blockquote:
+            return (
+                enabled: state.commands["toggleBlockquote"] == true,
+                active: state.nodes["blockquote"] == true
+            )
+        case .list:
+            switch item.listType {
+            case .bulletList, .legacyBulletList:
+                return (
+                    enabled: state.commands["wrapBulletList"] == true,
+                    active: state.nodes[item.listType?.rawValue ?? ""] == true
+                )
+            case .orderedList, .legacyOrderedList:
+                return (
+                    enabled: state.commands["wrapOrderedList"] == true,
+                    active: state.nodes[item.listType?.rawValue ?? ""] == true
+                )
+            case .none:
+                return (enabled: false, active: false)
+            }
+        case .command:
+            switch item.command {
+            case .indentList:
+                return (
+                    enabled: state.commands["indentList"] == true,
+                    active: false
+                )
+            case .outdentList:
+                return (
+                    enabled: state.commands["outdentList"] == true,
+                    active: false
+                )
+            case .undo:
+                return (enabled: state.canUndo, active: false)
+            case .redo:
+                return (enabled: state.canRedo, active: false)
+            case .none:
+                return (enabled: false, active: false)
+            }
+        case .node:
+            let nodeType = item.nodeType ?? ""
+            return (
+                enabled: state.insertableNodes.contains(nodeType),
+                active: state.nodes[nodeType] == true
+            )
+        case .action:
+            return (
+                enabled: !item.isDisabled,
+                active: item.isActive
+            )
+        case .group:
+            let childStates = item.items.map { buttonState(for: $0, state: state) }
+            return (
+                enabled: childStates.contains { $0.enabled },
+                active: childStates.contains { $0.active } ||
+                    (
+                        (item.presentation ?? .expand) == .expand &&
+                            expandedGroupKey == item.key
+                    )
+            )
+        case .separator:
+            return (enabled: false, active: false)
+        }
+    }
+
+    func updateButtonAppearance(
+        _ button: UIButton,
+        item: NativeToolbarItem,
+        enabled: Bool,
+        active: Bool
+    ) {
+        let buttonStyle = item.buttonStyle
+        let tintColor: UIColor
+        if !enabled {
+            tintColor = buttonStyle?.disabledColor
+                ?? theme?.buttonDisabledColor
+                ?? (resolvedAppearance == .native
+                    ? UIColor.label.withAlphaComponent(Self.nativeDisabledButtonOpacity)
+                    : .tertiaryLabel)
+        } else if active {
+            tintColor = buttonStyle?.activeColor
+                ?? theme?.buttonActiveColor
+                ?? (resolvedAppearance == .native ? self.tintColor : .systemBlue)
+        } else {
+            tintColor = buttonStyle?.color
+                ?? theme?.buttonColor
+                ?? (resolvedAppearance == .native ? self.tintColor : .secondaryLabel)
+        }
+
+        button.tintColor = tintColor
+        button.setTitleColor(tintColor, for: .normal)
+        button.setTitleColor(tintColor, for: .disabled)
+        button.tintAdjustmentMode = enabled ? .automatic : .normal
+        button.alpha = enabled || resolvedAppearance == .native ? 1 : 0.7
+        let inactiveBackgroundColor = buttonStyle?.backgroundColor
+            ?? theme?.buttonBackgroundColor
+            ?? .clear
+        let activeBackgroundColor = buttonStyle?.activeBackgroundColor
+            ?? theme?.buttonActiveBackgroundColor
+            ?? (resolvedAppearance == .native
+                ? UIColor.white.withAlphaComponent(0.18)
+                : UIColor.systemBlue.withAlphaComponent(0.12))
+        let disabledBackgroundColor = buttonStyle?.disabledBackgroundColor
+            ?? theme?.buttonDisabledBackgroundColor
+            ?? (active ? activeBackgroundColor : inactiveBackgroundColor)
+        let backgroundColor: UIColor
+        if !enabled {
+            backgroundColor = disabledBackgroundColor
+        } else if active {
+            backgroundColor = activeBackgroundColor
+        } else {
+            backgroundColor = inactiveBackgroundColor
+        }
+        let cornerRadius = resolvedButtonBorderRadius(for: item)
+        button.layer.cornerRadius = cornerRadius
+        applyButtonBackground(
+            to: button,
+            color: backgroundColor,
+            cornerRadius: cornerRadius
+        )
+        applyButtonIconStyle(to: button, item: item)
+    }
+
+    /// Own the configured background to avoid stacking it with UIButton state fills.
+    private func applyButtonBackground(
+        to button: UIButton,
+        color: UIColor,
+        cornerRadius: CGFloat
+    ) {
+        guard #available(iOS 15.0, *), var configuration = button.configuration else {
+            button.backgroundColor = color
+            return
+        }
+        var background = UIBackgroundConfiguration.clear()
+        background.backgroundColor = color
+        background.cornerRadius = cornerRadius
+        configuration.background = background
+        button.configuration = configuration
+        button.backgroundColor = .clear
+    }
+
+    func resolvedButtonBorderRadius(for item: NativeToolbarItem) -> CGFloat {
+        guard let radius = item.buttonStyle?.borderRadius, radius.isFinite else {
+            return max(0, resolvedButtonBorderRadius)
+        }
+        return max(0, radius)
+    }
+
+    private func resolvedButtonIconSize(for item: NativeToolbarItem) -> CGFloat {
+        let requestedSize = item.buttonStyle?.iconSize ?? theme?.buttonIconSize
+        guard let requestedSize, requestedSize.isFinite, requestedSize > 0 else {
+            return 16
+        }
+        return min(requestedSize, resolvedButtonSize)
+    }
+
+    private func applyButtonIconStyle(to button: UIButton, item: NativeToolbarItem) {
+        let iconSize = resolvedButtonIconSize(for: item)
+        let font = UIFont.systemFont(ofSize: iconSize, weight: .semibold)
+        if #available(iOS 15.0, *), var configuration = button.configuration {
+            configuration.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { incoming in
+                var outgoing = incoming
+                outgoing.font = font
+                return outgoing
+            }
+            button.configuration = configuration
+            button.updateConfiguration()
+        }
+        button.titleLabel?.font = font
+        if button.image(for: .normal) != nil {
+            button.setPreferredSymbolConfiguration(
+                UIImage.SymbolConfiguration(pointSize: iconSize, weight: .semibold),
+                forImageIn: .normal
+            )
+        }
+    }
+
+    func resolvedBlurEffect() -> UIVisualEffect {
+        #if compiler(>=6.2)
+            if #available(iOS 26.0, *) {
+                let effect = UIGlassEffect(style: .regular)
+                effect.isInteractive = true
+                effect.tintColor = resolvedGlassEffectTintColor
+                return effect
+            }
+        #endif
+        if #available(iOS 13.0, *) {
+            return UIBlurEffect(style: .systemUltraThinMaterial)
+        }
+        return UIBlurEffect(style: .extraLight)
+    }
+
+}

package/ios/NativeToolbar+Buttons.swift

@@ -0,0 +1,228 @@
+import UIKit
+
+extension EditorAccessoryToolbarView {
+    func rebuildButtons() {
+        if #available(iOS 16.0, *) {
+            (editMenuPresenter as? ToolbarEditMenuPresenter)?.dismiss()
+        }
+        buttonBindings.removeAll()
+        separators.removeAll()
+        for arrangedSubview in startPinnedStackView.arrangedSubviews {
+            startPinnedStackView.removeArrangedSubview(arrangedSubview)
+            arrangedSubview.removeFromSuperview()
+        }
+        for arrangedSubview in stackView.arrangedSubviews {
+            stackView.removeArrangedSubview(arrangedSubview)
+            arrangedSubview.removeFromSuperview()
+        }
+        for arrangedSubview in endPinnedStackView.arrangedSubviews {
+            endPinnedStackView.removeArrangedSubview(arrangedSubview)
+            arrangedSubview.removeFromSuperview()
+        }
+
+        let visibleItems = visibleToolbarItemsByPlacement()
+        rebuildButtons(items: visibleItems.start, in: startPinnedStackView)
+        rebuildButtons(items: visibleItems.scroll, in: stackView)
+        rebuildButtons(items: visibleItems.end, in: endPinnedStackView)
+        updatePinnedStackParticipation()
+        apply(theme: theme)
+        apply(state: currentState)
+    }
+
+    /// Exclude an empty pinned stack from `bodyStackView` entirely.
+    ///
+    /// Horizontal hugging cannot hold an empty `UIStackView` at zero width:
+    /// hugging only resists growing beyond an *intrinsic* size, and an empty
+    /// stack has none. With nothing to hug to, `bodyStackView`'s fill
+    /// distribution is free to hand the whole row to an empty pinned stack,
+    /// collapsing the scrolling middle that holds every button. Hiding an
+    /// arranged subview removes it from the distribution outright, which is
+    /// the only unambiguous way to say "this edge takes no space".
+    private func updatePinnedStackParticipation() {
+        startPinnedStackView.isHidden = startPinnedStackView.arrangedSubviews.isEmpty
+        endPinnedStackView.isHidden = endPinnedStackView.arrangedSubviews.isEmpty
+    }
+
+    func rebuildButtons(items: [NativeToolbarItem], in container: UIStackView) {
+        for item in items {
+            if item.type == .separator {
+                container.addArrangedSubview(makeSeparator())
+                continue
+            }
+
+            container.addArrangedSubview(makeButton(item: item))
+        }
+    }
+
+    private func compactToolbarItems(_ items: [NativeToolbarItem]) -> [NativeToolbarItem] {
+        items.enumerated().filter { index, item in
+            guard item.type == .separator else { return true }
+            guard index > 0, index < items.count - 1 else { return false }
+            return items[index - 1].type != .separator && items[index + 1].type != .separator
+        }.map(\.element)
+    }
+
+    private func visibleToolbarItems() -> [NativeToolbarItem] {
+        var visible: [NativeToolbarItem] = []
+        for item in compactToolbarItems(items) {
+            visible.append(item)
+            if item.type == .group,
+               (item.presentation ?? .expand) == .expand,
+               expandedGroupKey == item.key {
+                visible.append(contentsOf: item.items.map {
+                    $0.with(parentGroupKey: item.key, inheritedPlacement: item.placement)
+                })
+            }
+        }
+        return compactToolbarItems(visible)
+    }
+
+    private func visibleToolbarItemsByPlacement() -> VisibleToolbarItemsByPlacement {
+        var start: [NativeToolbarItem] = []
+        var scroll: [NativeToolbarItem] = []
+        var end: [NativeToolbarItem] = []
+
+        for item in visibleToolbarItems() {
+            switch item.placement ?? .scroll {
+            case .start:
+                start.append(item)
+            case .scroll:
+                scroll.append(item)
+            case .end:
+                end.append(item)
+            }
+        }
+
+        return VisibleToolbarItemsByPlacement(
+            start: compactToolbarItems(start),
+            scroll: compactToolbarItems(scroll),
+            end: compactToolbarItems(end)
+        )
+    }
+
+    private func handleToolbarButtonPress(_ item: NativeToolbarItem) {
+        switch item.type {
+        case .group:
+            handleGroupPress(item)
+        default:
+            onPressItem?(item.with(parentGroupKey: nil))
+            if let parentGroupKey = item.parentGroupKey,
+               expandedGroupKey == parentGroupKey {
+                expandedGroupKey = nil
+                rebuildButtons()
+            }
+        }
+    }
+
+    private func handleGroupPress(_ item: NativeToolbarItem) {
+        guard item.type == .group, !item.items.isEmpty else { return }
+        switch item.presentation ?? .expand {
+        case .expand:
+            expandedGroupKey = expandedGroupKey == item.key ? nil : item.key
+            rebuildButtons()
+        case .menu:
+            break
+        }
+    }
+
+    private func presentGroupMenu(_ item: NativeToolbarItem, from sourceButton: UIButton) {
+        guard #available(iOS 16.0, *),
+              let presenter = editMenuPresenter as? ToolbarEditMenuPresenter
+        else {
+            return
+        }
+        presenter.toggle(from: sourceButton) { [weak self] in
+            self?.makeGroupMenu(item: item)
+        }
+    }
+
+    private func makeGroupMenu(item: NativeToolbarItem) -> UIMenu? {
+        guard item.type == .group else { return nil }
+        let actions = item.items.compactMap { child -> UIAction? in
+            let state = buttonState(for: child, state: currentState)
+            let image = child.icon?.resolvedSFSymbolName().flatMap { UIImage(systemName: $0) }
+            let title = child.label ?? child.icon?.resolvedGlyphText() ?? "Item"
+            return UIAction(
+                title: title,
+                image: image,
+                identifier: nil,
+                discoverabilityTitle: child.label,
+                attributes: state.enabled ? [] : [.disabled],
+                state: state.active ? .on : .off
+            ) { [weak self] _ in
+                self?.handleToolbarButtonPress(child)
+            }
+        }
+        guard !actions.isEmpty else { return nil }
+        let menu = UIMenu(title: item.label ?? "", children: actions)
+        menu.preferredElementSize = .large
+        return menu
+    }
+
+    private func makeButton(item: NativeToolbarItem) -> UIButton {
+        let button = UIButton(type: .system)
+        button.translatesAutoresizingMaskIntoConstraints = false
+        button.accessibilityLabel = item.label
+        button.layer.cornerRadius = resolvedButtonBorderRadius(for: item)
+        button.clipsToBounds = true
+        if #available(iOS 15.0, *) {
+            var configuration = UIButton.Configuration.plain()
+            configuration.contentInsets = NSDirectionalEdgeInsets(
+                top: 8,
+                leading: 10,
+                bottom: 8,
+                trailing: 10
+            )
+            button.configuration = configuration
+        } else {
+            button.contentEdgeInsets = UIEdgeInsets(top: 8, left: 10, bottom: 8, right: 10)
+        }
+        if let symbolName = item.icon?.resolvedSFSymbolName(),
+           let symbolImage = UIImage(systemName: symbolName) {
+            button.setImage(symbolImage, for: .normal)
+            button.setTitle(nil, for: .normal)
+        } else {
+            button.setImage(nil, for: .normal)
+            button.setTitle(item.icon?.resolvedGlyphText() ?? "?", for: .normal)
+        }
+        let buttonSize = resolvedButtonSize
+        let widthConstraint = button.widthAnchor.constraint(greaterThanOrEqualToConstant: buttonSize)
+        let heightConstraint = button.heightAnchor.constraint(equalToConstant: buttonSize)
+        widthConstraint.isActive = true
+        heightConstraint.isActive = true
+        if item.type == .group,
+           (item.presentation ?? .expand) == .menu,
+           #available(iOS 16.0, *) {
+            button.accessibilityHint = "Shows menu"
+            button.addAction(UIAction { [weak self, weak button] _ in
+                guard let button else { return }
+                self?.presentGroupMenu(item, from: button)
+            }, for: .touchUpInside)
+        } else {
+            button.addAction(UIAction { [weak self] _ in
+                self?.handleToolbarButtonPress(item)
+            }, for: .touchUpInside)
+        }
+        updateButtonAppearance(button, item: item, enabled: true, active: false)
+        buttonBindings.append(
+            ButtonBinding(
+                item: item,
+                button: button,
+                widthConstraint: widthConstraint,
+                heightConstraint: heightConstraint
+            )
+        )
+        return button
+    }
+
+    private func makeSeparator() -> UIView {
+        let separator = UIView()
+        separator.translatesAutoresizingMaskIntoConstraints = false
+        separator.backgroundColor = .separator
+        separator.widthAnchor.constraint(equalToConstant: 1 / UIScreen.main.scale).isActive = true
+        separator.heightAnchor.constraint(equalToConstant: 22).isActive = true
+        separators.append(separator)
+        return separator
+    }
+
+}