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

package/ios/NativeCodeHighlighting.swift

@@ -0,0 +1,159 @@
+import Foundation
+
+public struct NativeCodeHighlightRange {
+    public let start: Int
+    public let length: Int
+    public let color: UInt32
+    public let fontStyle: UInt8
+
+    public init(start: Int, length: Int, color: UInt32, fontStyle: UInt8) {
+        self.start = start
+        self.length = length
+        self.color = color
+        self.fontStyle = fontStyle
+    }
+}
+
+public protocol NativeCodeHighlightingProvider: AnyObject {
+    var id: String { get }
+    var version: Int { get }
+    func highlight(text: String, language: String?, theme: String) throws -> [NativeCodeHighlightRange]
+}
+
+public enum NativeCodeHighlightingRegistry {
+    private static let lock = NSLock()
+    private static var providers: [String: NativeCodeHighlightingProvider] = [:]
+
+    public static func register(provider: NativeCodeHighlightingProvider) throws {
+        guard !provider.id.isEmpty, provider.version == 1 else {
+            throw failure("Code highlighting provider must have an ID and support version 1")
+        }
+        lock.lock()
+        defer { lock.unlock() }
+        providers[provider.id] = provider
+    }
+
+    public static func provider(id: String) throws -> NativeCodeHighlightingProvider {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let provider = providers[id] else {
+            throw failure("Code highlighting provider '\(id)' is unavailable. Install and import its native package, then rebuild the app.")
+        }
+        return provider
+    }
+
+    static func validRanges(text: String, ranges: [NativeCodeHighlightRange]) -> Bool {
+        let units = Array(text.utf16)
+        func isBoundary(_ offset: Int) -> Bool {
+            offset == 0 || offset == units.count || !(0xD800...0xDBFF).contains(units[offset - 1]) || !(0xDC00...0xDFFF).contains(units[offset])
+        }
+        var end = 0
+        for range in ranges {
+            guard range.start >= end, range.length > 0, range.start <= units.count,
+                  range.length <= units.count - range.start, range.fontStyle <= 7,
+                  isBoundary(range.start), isBoundary(range.start + range.length) else { return false }
+            end = range.start + range.length
+        }
+        return true
+    }
+
+    private static func failure(_ message: String) -> NSError {
+        NSError(domain: "NativeCodeHighlighting", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+    }
+}
+
+struct NativeCodeHighlightBlock {
+    let start: Int
+    let text: String
+    let language: String?
+}
+
+struct NativeHighlightedCodeBlock {
+    let block: NativeCodeHighlightBlock
+    let ranges: [NativeCodeHighlightRange]
+}
+
+final class NativeCodeHighlightingSession {
+    private struct Request {
+        let generation: UInt64
+        let provider: NativeCodeHighlightingProvider
+        let theme: String
+        let blocks: [NativeCodeHighlightBlock]
+        let completion: (Result<[NativeHighlightedCodeBlock], Error>) -> Void
+    }
+
+    private static let queue = DispatchQueue(label: "editor.code-highlighting", qos: .userInitiated)
+    private let lock = NSLock()
+    private var generation: UInt64 = 0
+    private var pending: Request?
+    private var running = false
+
+    func cancel() {
+        precondition(Thread.isMainThread, "Highlighting sessions must be updated on the main thread")
+        lock.lock()
+        generation &+= 1
+        pending = nil
+        lock.unlock()
+    }
+
+    func update(
+        provider id: String,
+        theme: String,
+        blocks: [NativeCodeHighlightBlock],
+        completion: @escaping (Result<[NativeHighlightedCodeBlock], Error>) -> Void
+    ) throws {
+        cancel()
+        let provider = try NativeCodeHighlightingRegistry.provider(id: id)
+        lock.lock()
+        pending = Request(generation: generation, provider: provider, theme: theme, blocks: blocks, completion: completion)
+        let schedule = !running
+        running = true
+        lock.unlock()
+        if schedule { Self.queue.async { [weak self] in self?.drain() } }
+    }
+
+    private func current(_ value: UInt64) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return generation == value
+    }
+
+    private func takeRequest() -> Request? {
+        lock.lock()
+        defer { lock.unlock() }
+        let request = pending
+        pending = nil
+        if request == nil { running = false }
+        return request
+    }
+
+    private func scheduleNext() {
+        lock.lock()
+        let schedule = pending != nil
+        running = schedule
+        lock.unlock()
+        if schedule { Self.queue.async { [weak self] in self?.drain() } }
+    }
+
+    private func drain() {
+        guard let request = takeRequest() else { return }
+        defer { scheduleNext() }
+        let result = Result<[NativeHighlightedCodeBlock], Error> {
+            var output: [NativeHighlightedCodeBlock] = []
+            for block in request.blocks {
+                guard current(request.generation) else { return [] }
+                let ranges = try request.provider.highlight(text: block.text, language: block.language, theme: request.theme)
+                guard NativeCodeHighlightingRegistry.validRanges(text: block.text, ranges: ranges) else {
+                    throw NSError(domain: "NativeCodeHighlighting", code: 2, userInfo: [NSLocalizedDescriptionKey: "Code highlighting provider returned invalid UTF-16 ranges"])
+                }
+                output.append(NativeHighlightedCodeBlock(block: block, ranges: ranges))
+            }
+            return output
+        }
+        guard current(request.generation) else { return }
+        DispatchQueue.main.async { [weak self] in
+            guard self?.current(request.generation) == true else { return }
+            request.completion(result)
+        }
+    }
+}

package/ios/NativeCollaborationSocket.swift

@@ -0,0 +1,144 @@
+import Foundation
+
+struct CollaborationSocketCallbacks {
+    let didOpen: (_ negotiatedProtocol: String?) -> Void
+    let didClose: (_ code: URLSessionWebSocketTask.CloseCode, _ reason: Data?) -> Void
+    let didFail: () -> Void
+}
+
+enum CollaborationSocketMessage {
+    case binary(Data)
+    case text(String)
+}
+
+protocol CollaborationSocket: AnyObject {
+    func resume()
+    func sendBinary(_ data: Data, completion: @escaping (Result<Void, Error>) -> Void)
+    func sendText(_ text: String, completion: @escaping (Result<Void, Error>) -> Void)
+    func receive(_ completion: @escaping (Result<CollaborationSocketMessage, Error>) -> Void)
+    func cancel(code: URLSessionWebSocketTask.CloseCode, reason: Data?)
+}
+
+protocol CollaborationSocketFactory {
+    func makeSocket(
+        url: URL,
+        protocols: [String],
+        callbacks: CollaborationSocketCallbacks
+    ) -> CollaborationSocket
+}
+
+struct URLSessionCollaborationSocketFactory: CollaborationSocketFactory {
+    func makeSocket(
+        url: URL,
+        protocols: [String],
+        callbacks: CollaborationSocketCallbacks
+    ) -> CollaborationSocket {
+        NativeCollaborationSocket(url: url, protocols: protocols, callbacks: callbacks)
+    }
+}
+
+/// URLSession owns only WebSocket I/O. Generation admission, retry policy,
+/// ordering, and retained outbound bytes remain in Rust/the transport driver.
+final class NativeCollaborationSocket: NSObject, CollaborationSocket, URLSessionWebSocketDelegate {
+    static let maximumMessageBytes = 64 * 1_024 * 1_024
+
+    private let callbacks: CollaborationSocketCallbacks
+    private let finishSession: (URLSession) -> Void
+    private var session: URLSession!
+    private var task: URLSessionWebSocketTask!
+
+    var maximumMessageSizeForTesting: Int {
+        task.maximumMessageSize
+    }
+
+    init(
+        url: URL,
+        protocols: [String],
+        callbacks: CollaborationSocketCallbacks,
+        finishSession: @escaping (URLSession) -> Void = { $0.finishTasksAndInvalidate() }
+    ) {
+        self.callbacks = callbacks
+        self.finishSession = finishSession
+        super.init()
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.httpShouldSetCookies = false
+        configuration.httpCookieStorage = nil
+        configuration.urlCredentialStorage = nil
+        configuration.urlCache = nil
+        configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        task = session.webSocketTask(with: url, protocols: protocols)
+        task.maximumMessageSize = Self.maximumMessageBytes
+    }
+
+    func resume() {
+        task.resume()
+    }
+
+    func sendBinary(_ data: Data, completion: @escaping (Result<Void, Error>) -> Void) {
+        task.send(.data(data)) { error in
+            if let error {
+                completion(.failure(error))
+            } else {
+                completion(.success(()))
+            }
+        }
+    }
+
+    func sendText(_ text: String, completion: @escaping (Result<Void, Error>) -> Void) {
+        task.send(.string(text)) { error in
+            if let error {
+                completion(.failure(error))
+            } else {
+                completion(.success(()))
+            }
+        }
+    }
+
+    func receive(_ completion: @escaping (Result<CollaborationSocketMessage, Error>) -> Void) {
+        task.receive { result in
+            switch result {
+            case .failure(let error):
+                completion(.failure(error))
+            case .success(.data(let data)):
+                completion(.success(.binary(data)))
+            case .success(.string(let text)):
+                completion(.success(.text(text)))
+            @unknown default:
+                completion(.failure(URLError(.cannotDecodeContentData)))
+            }
+        }
+    }
+
+    func cancel(code: URLSessionWebSocketTask.CloseCode, reason: Data?) {
+        task.cancel(with: code, reason: reason)
+        session.invalidateAndCancel()
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        webSocketTask: URLSessionWebSocketTask,
+        didOpenWithProtocol protocol: String?
+    ) {
+        callbacks.didOpen(`protocol`)
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        webSocketTask: URLSessionWebSocketTask,
+        didCloseWith closeCode: URLSessionWebSocketTask.CloseCode,
+        reason: Data?
+    ) {
+        finishSession(session)
+        callbacks.didClose(closeCode, reason)
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        task: URLSessionTask,
+        didCompleteWithError error: Error?
+    ) {
+        guard error != nil else { return }
+        callbacks.didFail()
+    }
+}

package/ios/NativeCollaborationTransport+Protocol.swift

@@ -0,0 +1,258 @@
+import Foundation
+
+extension FfiError: Error {}
+
+struct NativeCollaborationTransportConfig: Equatable {
+    static let maximumURLBytes = 4_096
+
+    let url: URL
+    let connect: Bool
+    let protocolAdapter: NativeCollaborationProtocolAdapterConfig?
+    let diagnosticEndpoint: String
+
+    init(
+        url: URL,
+        connect: Bool,
+        protocolAdapter: NativeCollaborationProtocolAdapterConfig?
+    ) throws {
+        guard let absolute = url.absoluteString.data(using: .utf8),
+              !absolute.isEmpty,
+              absolute.count <= Self.maximumURLBytes,
+              let scheme = url.scheme?.lowercased(),
+              scheme == "ws" || scheme == "wss",
+              url.host?.isEmpty == false,
+              url.user == nil,
+              url.password == nil,
+              url.fragment == nil
+        else {
+            throw NativeCollaborationTransportConfigurationError.invalidURL
+        }
+
+        guard let liveComponents = URLComponents(
+            url: url,
+            resolvingAgainstBaseURL: false
+        ) else {
+            throw NativeCollaborationTransportConfigurationError.invalidURL
+        }
+        var diagnostic = URLComponents()
+        diagnostic.scheme = scheme
+        diagnostic.host = url.host
+        diagnostic.port = url.port
+        diagnostic.percentEncodedPath = liveComponents.percentEncodedPath
+        guard let endpoint = diagnostic.string else {
+            throw NativeCollaborationTransportConfigurationError.invalidURL
+        }
+        self.url = url
+        self.connect = connect
+        self.protocolAdapter = protocolAdapter
+        diagnosticEndpoint = endpoint
+    }
+
+    static func == (
+        lhs: NativeCollaborationTransportConfig,
+        rhs: NativeCollaborationTransportConfig
+    ) -> Bool {
+        lhs.url.absoluteString == rhs.url.absoluteString
+            && lhs.connect == rhs.connect
+            && lhs.protocolAdapter == rhs.protocolAdapter
+    }
+}
+
+enum NativeCollaborationTransportConfigurationError: Error {
+    case invalidURL
+}
+
+struct NativeCollaborationProtocolAdapterConfig: Equatable {
+    static let defaultTimeoutMillis: UInt64 = 10_000
+    static let maximumFrameBytes = 64 * 1_024
+
+    let protocols: [String]
+    let timeoutMillis: UInt64
+    let terminalCloseCodes: Set<UInt32>
+}
+
+enum NativeCollaborationProtocolFrame {
+    case text(String)
+    case binary(Data)
+}
+
+enum NativeCollaborationProtocolAdapterAction {
+    case `continue`
+    case ready
+    case reject
+}
+
+struct NativeCollaborationProtocolAdapterResponse {
+    let action: NativeCollaborationProtocolAdapterAction
+    let frames: [NativeCollaborationProtocolFrame]
+}
+
+enum NativeCollaborationProtocolAdapterPhase {
+    case open
+    case message(NativeCollaborationProtocolFrame)
+}
+
+struct NativeCollaborationProtocolAdapterEvent {
+    let attemptId: String
+    let eventId: String
+    let generation: String
+    let negotiatedProtocol: String?
+    let phase: NativeCollaborationProtocolAdapterPhase
+}
+
+enum CollaborationWakeReason: String {
+    case localMutation
+    case moduleMutation
+    case receive
+    case timer
+    case open
+    case reattach
+    case awareness
+}
+
+struct NativeCollaborationTransportDirective: Equatable {
+    let transportState: String
+    let generationToOpen: String?
+    let nextDeadlineMillis: String?
+    let remoteCommitApplied: Bool
+    let peersChanged: Bool
+    let renewedLocal: Bool
+    let expiredPeers: [String]
+}
+
+enum NativeCollaborationTransportEvent {
+    case directive(
+        directive: NativeCollaborationTransportDirective,
+        generation: String?,
+        wakeReason: CollaborationWakeReason
+    )
+    case error(FfiError, generation: String?)
+    case protocolAdapter(NativeCollaborationProtocolAdapterEvent)
+}
+
+protocol NativeCollaborationTransportBackend {
+    func drive(editorId: String, nowMillis: String) -> FfiJsonResult
+    func socketOpen(editorId: String, generation: String, nowMillis: String) -> FfiJsonResult
+    func receive(
+        editorId: String,
+        generation: String,
+        message: Data,
+        nowMillis: String
+    ) -> FfiJsonResult
+    func socketClose(
+        editorId: String,
+        generation: String,
+        code: UInt32?,
+        reason: String?,
+        nowMillis: String
+    ) -> FfiJsonResult
+    func leaseOutbound(editorId: String, generation: String) -> FfiOutboundLeaseResult
+    func ackOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult
+    func nackOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult
+    func detach(editorId: String) -> FfiUnitResult
+    func reattach(editorId: String) -> FfiUnitResult
+}
+
+struct RustNativeCollaborationTransportBackend: NativeCollaborationTransportBackend {
+    func drive(editorId: String, nowMillis: String) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationDrive(editorId: editorId, nowMillis: nowMillis)
+        }
+    }
+
+    func socketOpen(editorId: String, generation: String, nowMillis: String) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationSocketOpen(
+                editorId: editorId,
+                generation: generation,
+                nowMillis: nowMillis
+            )
+        }
+    }
+
+    func receive(
+        editorId: String,
+        generation: String,
+        message: Data,
+        nowMillis: String
+    ) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationReceive(
+                editorId: editorId,
+                generation: generation,
+                message: message,
+                nowMillis: nowMillis
+            )
+        }
+    }
+
+    func socketClose(
+        editorId: String,
+        generation: String,
+        code: UInt32?,
+        reason: String?,
+        nowMillis: String
+    ) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationSocketClose(
+                editorId: editorId,
+                generation: generation,
+                code: code,
+                reason: reason,
+                nowMillis: nowMillis
+            )
+        }
+    }
+
+    func leaseOutbound(editorId: String, generation: String) -> FfiOutboundLeaseResult {
+        performEditorV2OutboundLeaseOperation(editorId: editorId) {
+            editorV2CollaborationLeaseOutbound(editorId: editorId, generation: generation)
+        }
+    }
+
+    func ackOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationAckOutbound(
+                editorId: editorId,
+                generation: generation,
+                leaseId: leaseId
+            )
+        }
+    }
+
+    func nackOutbound(editorId: String, generation: String, leaseId: String) -> FfiJsonResult {
+        performEditorV2JsonOperation(editorId: editorId) {
+            editorV2CollaborationNackOutbound(
+                editorId: editorId,
+                generation: generation,
+                leaseId: leaseId
+            )
+        }
+    }
+
+    func detach(editorId: String) -> FfiUnitResult {
+        performEditorV2LifecycleUnitOperation(editorId: editorId) {
+            editorV2CollaborationDetach(editorId: editorId)
+        }
+    }
+
+    func reattach(editorId: String) -> FfiUnitResult {
+        performEditorV2UnitOperation(editorId: editorId) {
+            editorV2CollaborationReattach(editorId: editorId)
+        }
+    }
+}
+
+protocol CollaborationMonotonicClock {
+    func nowMillis() -> UInt64
+}
+
+struct SystemCollaborationMonotonicClock: CollaborationMonotonicClock {
+    func nowMillis() -> UInt64 {
+        let milliseconds = ProcessInfo.processInfo.systemUptime * 1_000
+        if milliseconds >= Double(UInt64.max) {
+            return UInt64.max
+        }
+        return UInt64(milliseconds.rounded(.down))
+    }
+}