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

package/ios/SharedNativeImagePipeline+Cache.swift

@@ -0,0 +1,189 @@
+import CryptoKit
+import ImageIO
+import UIKit
+
+struct ImageLoadingPolicy: Equatable {
+    static let `default` = ImageLoadingPolicy(
+        maxSourceBytes: 10 * 1024 * 1024,
+        connectTimeout: 10,
+        readTimeout: 20,
+        requestTimeout: 60,
+        maxConcurrentRequests: 2,
+        maxPendingRequests: 64,
+        maxDecodeDimension: 2_048
+    )
+
+    let maxSourceBytes: Int
+    let connectTimeout: TimeInterval
+    let readTimeout: TimeInterval
+    let requestTimeout: TimeInterval
+    let maxConcurrentRequests: Int
+    let maxPendingRequests: Int
+    let maxDecodeDimension: Int
+
+    static func from(json: String?) -> ImageLoadingPolicy {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let values = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return .default
+        }
+        let defaults = ImageLoadingPolicy.default
+        func positiveInteger(_ key: String, fallback: Int, ceiling: Int) -> Int {
+            guard let number = values[key] as? NSNumber,
+                  CFGetTypeID(number) != CFBooleanGetTypeID(),
+                  number.doubleValue.isFinite,
+                  number.doubleValue.rounded(.towardZero) == number.doubleValue,
+                  number.int64Value > 0,
+                  number.int64Value <= Int64(ceiling)
+            else {
+                return fallback
+            }
+            return number.intValue
+        }
+        return ImageLoadingPolicy(
+            maxSourceBytes: positiveInteger(
+                "maxSourceBytes",
+                fallback: defaults.maxSourceBytes,
+                ceiling: 64 * 1024 * 1024
+            ),
+            connectTimeout: TimeInterval(
+                positiveInteger(
+                    "connectTimeoutMs",
+                    fallback: Int(defaults.connectTimeout * 1_000),
+                    ceiling: 600_000
+                )
+            ) / 1_000,
+            readTimeout: TimeInterval(
+                positiveInteger(
+                    "readTimeoutMs",
+                    fallback: Int(defaults.readTimeout * 1_000),
+                    ceiling: 600_000
+                )
+            ) / 1_000,
+            requestTimeout: TimeInterval(
+                positiveInteger(
+                    "requestTimeoutMs",
+                    fallback: Int(defaults.requestTimeout * 1_000),
+                    ceiling: 600_000
+                )
+            ) / 1_000,
+            maxConcurrentRequests: positiveInteger(
+                "maxConcurrentRequests",
+                fallback: defaults.maxConcurrentRequests,
+                ceiling: 16
+            ),
+            maxPendingRequests: positiveInteger(
+                "maxPendingRequests",
+                fallback: defaults.maxPendingRequests,
+                ceiling: 512
+            ),
+            maxDecodeDimension: positiveInteger(
+                "maxDecodeDimensionPx",
+                fallback: defaults.maxDecodeDimension,
+                ceiling: 8_192
+            )
+        )
+    }
+}
+
+extension Notification.Name {
+    static let editorImageAttachmentDidLoad = Notification.Name(
+        "com.apollohg.editor.imageAttachmentDidLoad"
+    )
+}
+
+final class RenderImageCostCache {
+    private struct Entry {
+        let image: UIImage
+        let cost: Int
+        var access: UInt64
+    }
+
+    let lock = NSLock()
+    private let costLimit: Int
+    private var entries: [String: Entry] = [:]
+    private var access: UInt64 = 0
+    private(set) var totalCost = 0
+
+    init(costLimit: Int) {
+        self.costLimit = max(0, costLimit)
+    }
+
+    func image(forKey key: String) -> UIImage? {
+        lock.lock()
+        defer { lock.unlock() }
+        guard var entry = entries[key] else { return nil }
+        access &+= 1
+        entry.access = access
+        entries[key] = entry
+        return entry.image
+    }
+
+    func insert(_ image: UIImage, forKey key: String, cost: Int) {
+        lock.lock()
+        defer { lock.unlock() }
+        let boundedCost = max(0, cost)
+        if let previous = entries.removeValue(forKey: key) {
+            totalCost -= previous.cost
+        }
+        guard boundedCost <= costLimit else { return }
+        access &+= 1
+        entries[key] = Entry(image: image, cost: boundedCost, access: access)
+        totalCost += boundedCost
+        while totalCost > costLimit,
+              let oldest = entries.min(by: { $0.value.access < $1.value.access }) {
+            entries.removeValue(forKey: oldest.key)
+            totalCost -= oldest.value.cost
+        }
+    }
+}
+
+enum RenderImageCache {
+    static let cache = RenderImageCostCache(costLimit: 64 * 1024 * 1024)
+    static let cacheEntryOverhead = 128
+
+    static func key(source: String, policy: ImageLoadingPolicy) -> String {
+        let canonicalPolicy = [
+            String(policy.maxSourceBytes),
+            String(policy.connectTimeout.bitPattern),
+            String(policy.readTimeout.bitPattern),
+            String(policy.requestTimeout.bitPattern),
+            String(policy.maxConcurrentRequests),
+            String(policy.maxPendingRequests),
+            String(policy.maxDecodeDimension)
+        ].joined(separator: "|")
+        var input = Data(source.utf8)
+        input.append(0)
+        input.append(contentsOf: canonicalPolicy.utf8)
+        return SHA256.hash(data: input).map { String(format: "%02x", $0) }.joined()
+    }
+
+    static func decodedCost(_ image: UIImage) -> Int {
+        if let cgImage = image.cgImage {
+            return backingCost(
+                bytesPerRow: cgImage.bytesPerRow,
+                height: cgImage.height,
+                fallback: Int.max
+            )
+        }
+        let width = Int(image.size.width * image.scale)
+        let height = Int(image.size.height * image.scale)
+        let (pixels, pixelOverflow) = width.multipliedReportingOverflow(by: height)
+        guard !pixelOverflow else { return Int.max }
+        let (bytes, byteOverflow) = pixels.multipliedReportingOverflow(by: 4)
+        return byteOverflow ? Int.max : bytes
+    }
+
+    static func backingCost(bytesPerRow: Int, height: Int, fallback: Int) -> Int {
+        guard bytesPerRow >= 0, height >= 0 else { return fallback }
+        let (cost, overflow) = bytesPerRow.multipliedReportingOverflow(by: height)
+        return overflow ? Int.max : cost
+    }
+
+    static func retainedCost(_ image: UIImage) -> Int {
+        let metadataCost = 64 + cacheEntryOverhead
+        let (cost, overflow) = decodedCost(image).addingReportingOverflow(metadataCost)
+        return overflow ? Int.max : cost
+    }
+}

package/ios/SharedNativeImagePipeline+Transport.swift

@@ -0,0 +1,328 @@
+import CryptoKit
+import ImageIO
+import UIKit
+
+protocol ImageLoadingTask: AnyObject {
+    func cancel()
+}
+
+protocol ImageLoadingTransport: AnyObject {
+    func load(
+        _ url: URL,
+        policy: ImageLoadingPolicy,
+        completion: @escaping (Result<Data, Error>) -> Void
+    ) -> ImageLoadingTask
+}
+
+protocol ImageDataDecoding: AnyObject {
+    func decode(_ data: Data, maxDimension: Int) -> UIImage?
+}
+
+final class ImageRequestTimeoutController {
+    typealias Schedule = (TimeInterval, @escaping () -> Void) -> ImageLoadingTask
+
+    let connectTimeout: TimeInterval
+    let readTimeout: TimeInterval
+    let requestTimeout: TimeInterval
+    private let schedule: Schedule
+    private let onTimeout: () -> Void
+    let lock = NSLock()
+    private var phaseTimer: ImageLoadingTask?
+    private var totalTimer: ImageLoadingTask?
+    private var phaseGeneration: UInt64 = 0
+    private var totalGeneration: UInt64 = 0
+    var finished = false
+
+    init(
+        connectTimeout: TimeInterval,
+        readTimeout: TimeInterval,
+        requestTimeout: TimeInterval,
+        schedule: @escaping Schedule,
+        onTimeout: @escaping () -> Void
+    ) {
+        self.connectTimeout = connectTimeout
+        self.readTimeout = readTimeout
+        self.requestTimeout = requestTimeout
+        self.schedule = schedule
+        self.onTimeout = onTimeout
+    }
+
+    func start() {
+        lock.lock()
+        guard !finished, phaseTimer == nil, totalTimer == nil else {
+            lock.unlock()
+            return
+        }
+        phaseGeneration &+= 1
+        totalGeneration &+= 1
+        phaseTimer = makeTimer(after: connectTimeout, phase: true, generation: phaseGeneration)
+        totalTimer = makeTimer(after: requestTimeout, phase: false, generation: totalGeneration)
+        lock.unlock()
+    }
+
+    func receivedResponse() {
+        armPhase(after: readTimeout)
+    }
+
+    func receivedData() {
+        armPhase(after: readTimeout)
+    }
+
+    func cancel() {
+        lock.lock()
+        finished = true
+        let timers = [phaseTimer, totalTimer]
+        phaseTimer = nil
+        totalTimer = nil
+        lock.unlock()
+        timers.forEach { $0?.cancel() }
+    }
+
+    private func armPhase(after delay: TimeInterval) {
+        lock.lock()
+        guard !finished else {
+            lock.unlock()
+            return
+        }
+        phaseTimer?.cancel()
+        phaseGeneration &+= 1
+        phaseTimer = makeTimer(after: delay, phase: true, generation: phaseGeneration)
+        lock.unlock()
+    }
+
+    private func makeTimer(
+        after delay: TimeInterval,
+        phase: Bool,
+        generation: UInt64
+    ) -> ImageLoadingTask {
+        schedule(delay) { [weak self] in
+            guard let self else { return }
+            self.lock.lock()
+            let isCurrent = phase
+                ? generation == self.phaseGeneration && self.phaseTimer != nil
+                : generation == self.totalGeneration && self.totalTimer != nil
+            guard !self.finished, isCurrent else {
+                self.lock.unlock()
+                return
+            }
+            self.finished = true
+            let timers = [self.phaseTimer, self.totalTimer]
+            self.phaseTimer = nil
+            self.totalTimer = nil
+            self.lock.unlock()
+            timers.forEach { $0?.cancel() }
+            self.onTimeout()
+        }
+    }
+}
+
+final class DispatchImageTimeoutTask: ImageLoadingTask {
+    private let workItem: DispatchWorkItem
+
+    init(delay: TimeInterval, action: @escaping () -> Void) {
+        let item = DispatchWorkItem(block: action)
+        workItem = item
+        DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + delay, execute: item)
+    }
+
+    func cancel() {
+        workItem.cancel()
+    }
+}
+
+final class DefaultImageDataDecoder: ImageDataDecoding {
+    func decode(_ data: Data, maxDimension: Int) -> UIImage? {
+        guard let source = CGImageSourceCreateWithData(data as CFData, nil),
+              CGImageSourceGetType(source) != nil else {
+            return NativeSVGImageDecoder.decode(data, maxDimension: maxDimension)
+        }
+        let options: [CFString: Any] = [
+            kCGImageSourceCreateThumbnailFromImageAlways: true,
+            kCGImageSourceCreateThumbnailWithTransform: true,
+            kCGImageSourceThumbnailMaxPixelSize: maxDimension,
+            kCGImageSourceShouldCacheImmediately: true
+        ]
+        guard let image = CGImageSourceCreateThumbnailAtIndex(source, 0, options as CFDictionary)
+        else {
+            return NativeSVGImageDecoder.decode(data, maxDimension: maxDimension)
+        }
+        return UIImage(cgImage: image)
+    }
+}
+
+final class URLSessionImageTask: NSObject, ImageLoadingTask, URLSessionDataDelegate {
+    let policy: ImageLoadingPolicy
+    let completion: (Result<Data, Error>) -> Void
+    let lock = NSLock()
+    private var buffer = Data()
+    private var session: URLSession?
+    var task: URLSessionDataTask?
+    private var timeoutController: ImageRequestTimeoutController?
+    var finished = false
+
+    init(url: URL, policy: ImageLoadingPolicy, completion: @escaping (Result<Data, Error>) -> Void) {
+        self.policy = policy
+        self.completion = completion
+        super.init()
+        let configuration = Self.configuration(policy: policy)
+        let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        self.session = session
+        let request = URLRequest(url: url)
+        let task = session.dataTask(with: request)
+        self.task = task
+        startTimeoutController { delay, action in
+            DispatchImageTimeoutTask(delay: delay, action: action)
+        }
+        task.resume()
+    }
+
+    init(
+        policy: ImageLoadingPolicy,
+        timeoutSchedule: @escaping ImageRequestTimeoutController.Schedule,
+        completion: @escaping (Result<Data, Error>) -> Void
+    ) {
+        self.policy = policy
+        self.completion = completion
+        super.init()
+        startTimeoutController(schedule: timeoutSchedule)
+    }
+
+    static func configuration(policy: ImageLoadingPolicy) -> URLSessionConfiguration {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.timeoutIntervalForRequest = max(
+            policy.connectTimeout,
+            policy.readTimeout
+        )
+        configuration.timeoutIntervalForResource = policy.requestTimeout
+        return configuration
+    }
+
+    func cancel() {
+        finish(.failure(URLError(.cancelled)), deliver: false)
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        dataTask: URLSessionDataTask,
+        didReceive response: URLResponse,
+        completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+    ) {
+        if response.expectedContentLength > Int64(policy.maxSourceBytes) {
+            completionHandler(.cancel)
+            finish(.failure(URLError(.dataLengthExceedsMaximum)))
+            return
+        }
+        lock.lock()
+        guard !finished else {
+            lock.unlock()
+            completionHandler(.cancel)
+            return
+        }
+        let timeoutController = self.timeoutController
+        lock.unlock()
+        timeoutController?.receivedResponse()
+        completionHandler(.allow)
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        lock.lock()
+        guard !finished else {
+            lock.unlock()
+            return
+        }
+        let exceedsLimit = Self.wouldExceedLimit(
+            currentCount: buffer.count,
+            incomingCount: data.count,
+            maxBytes: policy.maxSourceBytes
+        )
+        if !exceedsLimit {
+            buffer.append(data)
+        }
+        let timeoutController = exceedsLimit ? nil : self.timeoutController
+        lock.unlock()
+        guard !exceedsLimit else {
+            finish(.failure(URLError(.dataLengthExceedsMaximum)))
+            return
+        }
+        timeoutController?.receivedData()
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        task: URLSessionTask,
+        didCompleteWithError error: Error?
+    ) {
+        if let error {
+            finish(.failure(error))
+        } else {
+            lock.lock()
+            let data = buffer
+            lock.unlock()
+            finish(.success(data))
+        }
+    }
+
+    static func wouldExceedLimit(
+        currentCount: Int,
+        incomingCount: Int,
+        maxBytes: Int
+    ) -> Bool {
+        guard currentCount >= 0, incomingCount >= 0, maxBytes >= 0 else { return true }
+        guard incomingCount <= maxBytes else { return true }
+        return currentCount > maxBytes - incomingCount
+    }
+
+    private func startTimeoutController(
+        schedule: @escaping ImageRequestTimeoutController.Schedule
+    ) {
+        let timeoutController = ImageRequestTimeoutController(
+            connectTimeout: policy.connectTimeout,
+            readTimeout: policy.readTimeout,
+            requestTimeout: policy.requestTimeout,
+            schedule: schedule,
+            onTimeout: { [weak self] in
+                self?.finish(.failure(URLError(.timedOut)))
+            }
+        )
+        lock.lock()
+        guard !finished else {
+            lock.unlock()
+            return
+        }
+        self.timeoutController = timeoutController
+        lock.unlock()
+        timeoutController.start()
+    }
+
+    func finish(_ result: Result<Data, Error>, deliver: Bool = true) {
+        lock.lock()
+        guard !finished else {
+            lock.unlock()
+            return
+        }
+        finished = true
+        let timeoutController = self.timeoutController
+        let task = self.task
+        let session = self.session
+        self.task = nil
+        self.session = nil
+        self.timeoutController = nil
+        lock.unlock()
+        timeoutController?.cancel()
+        task?.cancel()
+        session?.invalidateAndCancel()
+        if deliver {
+            completion(result)
+        }
+    }
+}
+
+final class URLSessionImageTransport: ImageLoadingTransport {
+    func load(
+        _ url: URL,
+        policy: ImageLoadingPolicy,
+        completion: @escaping (Result<Data, Error>) -> Void
+    ) -> ImageLoadingTask {
+        URLSessionImageTask(url: url, policy: policy, completion: completion)
+    }
+}