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

package/ios/EditorTextView+DragDrop.swift

@@ -0,0 +1,290 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    enum LocalTextDragState {
+        case idle
+        case dragging(
+            session: ObjectIdentifier,
+            editorId: UInt64,
+            documentRevision: UInt64,
+            supported: Bool,
+            range: (from: UInt32, to: UInt32)
+        )
+        case awaitingUIKitCleanup(
+            session: ObjectIdentifier,
+            editorId: UInt64,
+            cleanupRanges: [NSRange]
+        )
+    }
+
+    func textDraggableView(
+        _ textDraggableView: UIView & UITextDraggable,
+        itemsForDrag dragRequest: UITextDragRequest
+    ) -> [UIDragItem] {
+        let requestedRange = PositionBridge.textRangeToScalarRange(
+            dragRequest.dragRange,
+            in: self
+        )
+        let range = scalarRange(for: dragRequest)
+        if editorId != 0,
+           range.from < range.to,
+           let documentRevision = EditorV2Shadow.documentRevision(id: editorId) {
+            let narrowedToVoidAttachment = !dragRequest.isSelected
+                && (range.from != requestedRange.from || range.to != requestedRange.to)
+            localTextDragState = .dragging(
+                session: ObjectIdentifier(dragRequest.dragSession as AnyObject),
+                editorId: editorId,
+                documentRevision: documentRevision,
+                supported: narrowedToVoidAttachment
+                    || containsNoBlockBoundary(dragRequest.dragRange),
+                range: range
+            )
+        }
+        return dragRequest.suggestedItems
+    }
+
+    private func containsNoBlockBoundary(_ range: UITextRange) -> Bool {
+        let start = offset(from: beginningOfDocument, to: range.start)
+        let end = offset(from: beginningOfDocument, to: range.end)
+        guard start >= 0, end > start, end <= textStorage.length else { return false }
+        var containsBoundary = false
+        textStorage.enumerateAttribute(
+            RenderBridgeAttributes.blockBoundary,
+            in: NSRange(location: start, length: end - start)
+        ) { value, _, stop in
+            guard value != nil else { return }
+            containsBoundary = true
+            stop.pointee = true
+        }
+        return !containsBoundary
+    }
+
+    func scalarRange(for dragRequest: UITextDragRequest) -> (from: UInt32, to: UInt32) {
+        let range = PositionBridge.textRangeToScalarRange(dragRequest.dragRange, in: self)
+        guard !dragRequest.isSelected else { return range }
+
+        let start = offset(from: beginningOfDocument, to: dragRequest.dragRange.start)
+        let end = offset(from: beginningOfDocument, to: dragRequest.dragRange.end)
+        guard start >= 0, end > start, start < textStorage.length else { return range }
+        let length = min(end, textStorage.length) - start
+        var atomRange: (from: UInt32, to: UInt32)?
+        textStorage.enumerateAttribute(
+            .attachment,
+            in: NSRange(location: start, length: length)
+        ) { value, characterRange, stop in
+            guard value is NSTextAttachment,
+                  textStorage.attribute(
+                      RenderBridgeAttributes.voidNodeType,
+                      at: characterRange.location,
+                      effectiveRange: nil
+                  ) is String
+            else {
+                return
+            }
+            let from = PositionBridge.utf16OffsetToScalar(characterRange.location, in: self)
+            let to = PositionBridge.utf16OffsetToScalar(NSMaxRange(characterRange), in: self)
+            atomRange = (from, to)
+            stop.pointee = true
+        }
+        return atomRange ?? range
+    }
+
+    func textDroppableView(
+        _ textDroppableView: UIView & UITextDroppable,
+        proposalForDrop drop: UITextDropRequest
+    ) -> UITextDropProposal {
+        guard let drag = matchingLocalTextDrag(for: drop) else {
+            return drop.suggestedProposal
+        }
+        let destination = PositionBridge.textViewToScalar(drop.dropPosition, in: self)
+        guard drag.supported,
+              drag.documentRevision == EditorV2Shadow.documentRevision(id: editorId),
+              canMove(drag.range, to: destination)
+        else {
+            return UITextDropProposal(operation: .forbidden)
+        }
+
+        let proposal = UITextDropProposal(operation: .move)
+        proposal.dropAction = .insert
+        proposal.dropPerformer = .delegate
+        proposal.dropProgressMode = .custom
+        proposal.useFastSameViewOperations = false
+        return proposal
+    }
+
+    func textDroppableView(
+        _ textDroppableView: UIView & UITextDroppable,
+        willPerformDrop drop: UITextDropRequest
+    ) {
+        guard let drag = matchingLocalTextDrag(for: drop) else { return }
+        let destination = PositionBridge.textViewToScalar(drop.dropPosition, in: self)
+        guard drag.supported,
+              drag.documentRevision == EditorV2Shadow.documentRevision(id: editorId),
+              canMove(drag.range, to: destination)
+        else {
+            localTextDragState = .idle
+            return
+        }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return }
+        guard flushPendingNativeTextMutationCommitIfNeeded() else { return }
+        guard drag.documentRevision == EditorV2Shadow.documentRevision(id: editorId) else {
+            localTextDragState = .idle
+            return
+        }
+
+        let sourceStartUtf16 = PositionBridge.scalarToUtf16Offset(drag.range.from, in: self)
+        let sourceEndUtf16 = PositionBridge.scalarToUtf16Offset(drag.range.to, in: self)
+        let sourceUtf16Range = NSRange(
+            location: sourceStartUtf16,
+            length: max(0, sourceEndUtf16 - sourceStartUtf16)
+        )
+
+        var applied = false
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.moveSelectionAtScalar(
+                id: editorId,
+                scalarAnchor: drag.range.from,
+                scalarHead: drag.range.to,
+                destination: destination
+            )
+            applied = applyUpdateJSON(updateJSON)
+        }
+        if applied {
+            localTextDragState = .awaitingUIKitCleanup(
+                session: drag.session,
+                editorId: drag.editorId,
+                cleanupRanges: localTextDragCleanupRanges(
+                    sourceUtf16Range: sourceUtf16Range,
+                    sourceScalarRange: drag.range,
+                    destination: destination
+                )
+            )
+        } else {
+            localTextDragState = .idle
+        }
+    }
+
+    func textDroppableView(
+        _ textDroppableView: UIView & UITextDroppable,
+        previewForDroppingAllItemsWithDefault defaultPreview: UITargetedDragPreview
+    ) -> UITargetedDragPreview? {
+        defaultPreview
+    }
+
+    func textDraggableView(
+        _ textDraggableView: UIView & UITextDraggable,
+        dragSessionDidEnd session: UIDragSession,
+        with operation: UIDropOperation
+    ) {
+        finishLocalTextDrag(for: session)
+    }
+
+    private struct LocalTextDragMatch {
+        let session: ObjectIdentifier
+        let editorId: UInt64
+        let documentRevision: UInt64
+        let supported: Bool
+        let range: (from: UInt32, to: UInt32)
+    }
+
+    private func matchingLocalTextDrag(for drop: UITextDropRequest) -> LocalTextDragMatch? {
+        guard drop.isSameView,
+              let localSession = drop.dropSession.localDragSession,
+              case let .dragging(
+                  session,
+                  sourceEditorId,
+                  documentRevision,
+                  supported,
+                  range
+              ) = localTextDragState,
+              sourceEditorId == editorId,
+              session == ObjectIdentifier(localSession as AnyObject)
+        else {
+            return nil
+        }
+        return LocalTextDragMatch(
+            session: session,
+            editorId: sourceEditorId,
+            documentRevision: documentRevision,
+            supported: supported,
+            range: range
+        )
+    }
+
+    private func canMove(
+        _ range: (from: UInt32, to: UInt32),
+        to destination: UInt32
+    ) -> Bool {
+        destination < range.from || destination > range.to
+    }
+
+    private func finishLocalTextDrag(for session: UIDragSession) {
+        let sessionID = ObjectIdentifier(session as AnyObject)
+        guard case let .awaitingUIKitCleanup(completedSession, sourceEditorId, _) = localTextDragState,
+              completedSession == sessionID,
+              sourceEditorId == editorId
+        else {
+            if case let .dragging(activeSession, _, _, _, _) = localTextDragState,
+               activeSession == sessionID {
+                localTextDragState = .idle
+            }
+            return
+        }
+        scheduleLocalTextDragCleanup(session: sessionID, sourceEditorId: sourceEditorId)
+    }
+
+    private func scheduleLocalTextDragCleanup(
+        session: ObjectIdentifier,
+        sourceEditorId: UInt64
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self,
+                  case let .awaitingUIKitCleanup(activeSession, activeEditorId, _) = self.localTextDragState,
+                  activeSession == session,
+                  activeEditorId == sourceEditorId,
+                  activeEditorId == self.editorId
+            else {
+                return
+            }
+            if self.pendingNativeTextMutation != nil || self.nativeTextMutationCommitScheduled {
+                _ = self.drainPendingNativeTextMutation(
+                    allowAfterBlur: self.canAdoptNativeTextMutationAfterBlur(),
+                    allowWhileIntercepting: true
+                )
+            }
+            self.localTextDragState = .idle
+            self.restoreAfterLocalTextDragCleanup()
+        }
+    }
+
+    func restoreAfterLocalTextDragCleanup() {
+        if textStorage.string != lastAuthorizedText {
+            _ = applyAttributedRender(
+                NSAttributedString(attributedString: lastAuthorizedAttributedTextStorage),
+                usedPatch: false,
+                positionCacheUpdate: .invalidate
+            )
+        }
+        applyUpdateJSON(
+            EditorV2Shadow.getCurrentState(id: editorId),
+            notifyDelegate: false
+        )
+    }
+
+    private func localTextDragCleanupRanges(
+        sourceUtf16Range: NSRange,
+        sourceScalarRange: (from: UInt32, to: UInt32),
+        destination: UInt32
+    ) -> [NSRange] {
+        var ranges = [sourceUtf16Range]
+        if destination < sourceScalarRange.from {
+            ranges.append(NSRange(
+                location: sourceUtf16Range.location + sourceUtf16Range.length,
+                length: sourceUtf16Range.length
+            ))
+        }
+        return ranges
+    }
+
+}

package/ios/EditorTextView+ExternalComposition.swift

@@ -0,0 +1,364 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    struct ExternalTextCompositionState {
+        let sessionId: String
+        let startingAuthorizedText: String
+        let startingAuthorizedAttributedText: NSAttributedString
+        let startingSelectedUtf16Range: NSRange
+        var latestText: String
+    }
+
+    struct ExternalTextCompositionFinish {
+        let resultJSON: String
+        let adoptedUpdateJSON: String?
+        let succeeded: Bool
+    }
+
+    func beginExternalTextComposition(sessionId: String) -> String {
+        guard editorId != 0,
+              isEditable,
+              let adapter = EditorV2Registry.adapter(forLegacyId: editorId),
+              !adapter.isDestroyed
+        else {
+            return externalCompositionErrorJSON(
+                sessionId: sessionId,
+                code: "EXTERNAL_COMPOSITION_UNAVAILABLE",
+                message: "The native editor is unavailable or not editable"
+            )
+        }
+        guard externalTextCompositionTerminalResults[sessionId] == nil else {
+            return externalCompositionEndedErrorJSON(sessionId: sessionId)
+        }
+        guard let selectionJSON = adapter.selectionJSON(),
+              let selectionData = selectionJSON.data(using: .utf8),
+              let selection = try? JSONSerialization.jsonObject(with: selectionData) as? [String: Any],
+              selection["type"] as? String == "text"
+        else {
+            return externalCompositionErrorJSON(
+                sessionId: sessionId,
+                code: "EXTERNAL_COMPOSITION_SELECTION_INCOMPATIBLE",
+                message: "External composition requires a text selection"
+            )
+        }
+
+        if externalTextComposition != nil {
+            let finished = finishExternalTextComposition(
+                cause: "consumer",
+                finalText: nil,
+                cancel: false
+            )
+            guard finished?.succeeded == true else {
+                return externalCompositionErrorJSON(
+                    sessionId: sessionId,
+                    code: "EXTERNAL_COMPOSITION_COMMIT_FAILED",
+                    message: "The previous external text composition could not be committed"
+                )
+            }
+        } else if isComposing, !prepareForExternalEditorUpdate() {
+            return externalCompositionErrorJSON(
+                sessionId: sessionId,
+                code: "EXTERNAL_COMPOSITION_UNAVAILABLE",
+                message: "The active input composition could not be committed"
+            )
+        }
+        guard flushPendingNativeTextMutationCommitIfNeeded() else {
+            return externalCompositionErrorJSON(
+                sessionId: sessionId,
+                code: "EXTERNAL_COMPOSITION_UNAVAILABLE",
+                message: "Pending native input could not be committed"
+            )
+        }
+
+        let startingSelection = selectedRange.location == NSNotFound
+            ? NSRange(location: 0, length: 0)
+            : selectedRange
+        captureMarkedTextReplacementRangeIfNeeded()
+        externalTextComposition = ExternalTextCompositionState(
+            sessionId: sessionId,
+            startingAuthorizedText: lastAuthorizedText,
+            startingAuthorizedAttributedText: NSAttributedString(
+                attributedString: lastAuthorizedAttributedTextStorage
+            ),
+            startingSelectedUtf16Range: startingSelection,
+            latestText: ""
+        )
+        isComposing = true
+        return externalCompositionActiveJSON(sessionId: sessionId)
+    }
+
+    func updateExternalTextComposition(sessionId: String, text: String) -> String {
+        guard var state = externalTextComposition, state.sessionId == sessionId else {
+            return externalCompositionEndedErrorJSON(sessionId: sessionId)
+        }
+        performTransientTextMutation {
+            super.setMarkedText(
+                text,
+                selectedRange: NSRange(location: (text as NSString).length, length: 0)
+            )
+        }
+        state.latestText = text
+        externalTextComposition = state
+        refreshMarkedTextCompositionText(fallback: text)
+        refreshPlaceholderVisibility()
+        return externalCompositionActiveJSON(sessionId: sessionId)
+    }
+
+    func commitExternalTextComposition(sessionId: String, finalText: String) -> String {
+        guard externalTextComposition?.sessionId == sessionId else {
+            return externalTextCompositionTerminalResults[sessionId]
+                ?? externalCompositionEndedErrorJSON(sessionId: sessionId)
+        }
+        return finishExternalTextComposition(
+            cause: "consumer",
+            finalText: finalText,
+            cancel: false
+        )?.resultJSON ?? externalCompositionEndedErrorJSON(sessionId: sessionId)
+    }
+
+    func cancelExternalTextComposition(sessionId: String, cause: String) -> String {
+        guard ["consumer", "documentChange", "lifecycle"].contains(cause) else {
+            return externalCompositionErrorJSON(
+                sessionId: sessionId,
+                code: "EXTERNAL_COMPOSITION_CANCEL_CAUSE_INVALID",
+                message: "The external composition cancellation cause is invalid"
+            )
+        }
+        guard externalTextComposition?.sessionId == sessionId else {
+            return externalTextCompositionTerminalResults[sessionId]
+                ?? externalCompositionEndedErrorJSON(sessionId: sessionId)
+        }
+        return finishExternalTextComposition(
+            cause: cause,
+            finalText: nil,
+            cancel: true
+        )?.resultJSON ?? externalCompositionEndedErrorJSON(sessionId: sessionId)
+    }
+
+    func finishExternalTextCompositionBeforeInteractionIfNeeded() -> Bool {
+        guard externalTextComposition != nil else { return true }
+        return finishExternalTextComposition(
+            cause: "interaction",
+            finalText: nil,
+            cancel: false
+        )?.succeeded == true
+    }
+
+    func finishExternalTextComposition(
+        cause: String,
+        finalText: String?,
+        cancel: Bool
+    ) -> ExternalTextCompositionFinish? {
+        guard var state = externalTextComposition else { return nil }
+        if let finalText {
+            if finalText != state.latestText {
+                performTransientTextMutation {
+                    super.setMarkedText(
+                        finalText,
+                        selectedRange: NSRange(
+                            location: (finalText as NSString).length,
+                            length: 0
+                        )
+                    )
+                }
+                refreshMarkedTextCompositionText(fallback: finalText)
+            }
+            state.latestText = finalText
+            externalTextComposition = state
+        }
+
+        let replacementRange = trackedMarkedTextReplacementRange()
+        var authoritativeUpdateJSON: String?
+        if cancel,
+           editorId != 0,
+           let adapter = EditorV2Registry.adapter(forLegacyId: editorId),
+           !adapter.isDestroyed {
+            authoritativeUpdateJSON = adapter.currentStateJSON()
+        }
+        externalTextComposition = nil
+        finishTransientMarkedTextMutation()
+
+        if cancel {
+            restoreAuthorizedExternalComposition(
+                state,
+                authoritativeUpdateJSON: authoritativeUpdateJSON
+            )
+            let resultJSON = externalCompositionEndedJSON(
+                sessionId: state.sessionId,
+                outcome: "cancelled",
+                cause: cause,
+                text: state.latestText
+            )
+            emitExternalTextCompositionEnd(sessionId: state.sessionId, resultJSON: resultJSON)
+            return ExternalTextCompositionFinish(
+                resultJSON: resultJSON,
+                adoptedUpdateJSON: nil,
+                succeeded: true
+            )
+        }
+
+        _ = applyAttributedRender(
+            state.startingAuthorizedAttributedText,
+            usedPatch: false,
+            positionCacheUpdate: .scan
+        )
+        guard let commit = commitMarkedTextWithNativeOutcome(
+            state.latestText,
+            replacementRange: replacementRange
+        ) else {
+            let currentUpdateJSON: String?
+            if editorId == 0 {
+                currentUpdateJSON = nil
+            } else {
+                currentUpdateJSON = EditorV2Registry.adapter(forLegacyId: editorId)?
+                    .recoverNativeRender()
+            }
+            restoreAuthorizedExternalComposition(
+                state,
+                authoritativeUpdateJSON: currentUpdateJSON
+            )
+            let error = externalCompositionErrorPayload(
+                code: "EXTERNAL_COMPOSITION_COMMIT_FAILED",
+                message: "The external text composition could not be committed"
+            )
+            let resultJSON = externalCompositionEndedJSON(
+                sessionId: state.sessionId,
+                outcome: "cancelled",
+                cause: cause,
+                text: state.latestText,
+                error: error
+            )
+            emitExternalTextCompositionEnd(sessionId: state.sessionId, resultJSON: resultJSON)
+            return ExternalTextCompositionFinish(
+                resultJSON: resultJSON,
+                adoptedUpdateJSON: nil,
+                succeeded: false
+            )
+        }
+
+        let resultJSON = externalCompositionEndedJSON(
+            sessionId: state.sessionId,
+            outcome: "committed",
+            cause: cause,
+            text: state.latestText
+        )
+        emitExternalTextCompositionEnd(sessionId: state.sessionId, resultJSON: resultJSON)
+        return ExternalTextCompositionFinish(
+            resultJSON: resultJSON,
+            adoptedUpdateJSON: commit.updateJSON,
+            succeeded: true
+        )
+    }
+
+    private func restoreAuthorizedExternalComposition(
+        _ state: ExternalTextCompositionState,
+        authoritativeUpdateJSON: String? = nil
+    ) {
+        _ = applyAttributedRender(
+            state.startingAuthorizedAttributedText,
+            usedPatch: false,
+            positionCacheUpdate: .scan
+        )
+        if let authoritativeUpdateJSON {
+            _ = applyUpdateJSON(authoritativeUpdateJSON, notifyDelegate: false)
+        }
+        guard textStorage.string == state.startingAuthorizedText,
+              state.startingSelectedUtf16Range.location >= 0,
+              state.startingSelectedUtf16Range.length >= 0,
+              state.startingSelectedUtf16Range.location
+              + state.startingSelectedUtf16Range.length <= textStorage.length
+        else {
+            return
+        }
+
+        logicalSelectionScalarRange = nil
+        logicalSelectionUtf16Range = nil
+        performTransientTextMutation {
+            selectedRange = state.startingSelectedUtf16Range
+            noteSelectionDidChange()
+        }
+        recordAuthorizedSelectionIfPossible()
+        refreshTypingAttributesForSelection()
+    }
+
+    private func emitExternalTextCompositionEnd(sessionId: String, resultJSON: String) {
+        guard externalTextCompositionTerminalResults[sessionId] == nil else { return }
+        externalTextCompositionTerminalResults[sessionId] = resultJSON
+        editorDelegate?.editorTextView(self, didEndExternalTextComposition: resultJSON)
+    }
+
+    private func externalCompositionActiveJSON(sessionId: String) -> String {
+        externalCompositionResultJSON([
+            "version": 1,
+            "type": "active",
+            "sessionId": sessionId
+        ])
+    }
+
+    private func externalCompositionEndedJSON(
+        sessionId: String,
+        outcome: String,
+        cause: String,
+        text: String,
+        error: [String: Any]? = nil
+    ) -> String {
+        var payload: [String: Any] = [
+            "version": 1,
+            "type": "ended",
+            "sessionId": sessionId,
+            "outcome": outcome,
+            "cause": cause,
+            "text": text
+        ]
+        if let error {
+            payload["error"] = error
+        }
+        return externalCompositionResultJSON(payload)
+    }
+
+    private func externalCompositionEndedErrorJSON(sessionId: String) -> String {
+        externalCompositionErrorJSON(
+            sessionId: sessionId,
+            code: "EXTERNAL_COMPOSITION_ENDED",
+            message: "The external text composition session has ended"
+        )
+    }
+
+    private func externalCompositionErrorJSON(
+        sessionId: String?,
+        code: String,
+        message: String
+    ) -> String {
+        externalCompositionResultJSON([
+            "version": 1,
+            "type": "error",
+            "sessionId": sessionId.map { $0 as Any } ?? NSNull(),
+            "error": externalCompositionErrorPayload(code: code, message: message)
+        ])
+    }
+
+    private func externalCompositionErrorPayload(code: String, message: String) -> [String: Any] {
+        [
+            "domain": "lifecycle",
+            "code": code,
+            "message": message,
+            "requestId": NSNull(),
+            "operationIndex": NSNull(),
+            "limit": NSNull(),
+            "actual": NSNull(),
+            "details": NSNull()
+        ]
+    }
+
+    func externalCompositionResultJSON(_ payload: [String: Any]) -> String {
+        guard JSONSerialization.isValidJSONObject(payload),
+              let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return #"{"version":1,"type":"error","sessionId":null,"error":{"domain":"lifecycle","code":"EXTERNAL_COMPOSITION_RESULT_INVALID","message":"Could not serialize external composition result","requestId":null,"operationIndex":null,"limit":null,"actual":null,"details":null}}"#
+        }
+        return json
+    }
+
+}