mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-22 00:14:30 +00:00
1424 lines
49 KiB
Swift
1424 lines
49 KiB
Swift
import ExpoModulesCore
|
|
import UIKit
|
|
import UniformTypeIdentifiers
|
|
|
|
private struct ComposerTokenPayload: Decodable, Equatable {
|
|
let type: String
|
|
let source: String
|
|
let label: String
|
|
let iconUri: String?
|
|
let accent: String?
|
|
let tintsIcon: Bool?
|
|
let detail: String?
|
|
var start: Int
|
|
var end: Int
|
|
|
|
func rendersLike(_ other: Self) -> Bool {
|
|
var moved = other
|
|
moved.start = start
|
|
moved.end = end
|
|
// String == accepts canonically equivalent sources, but their UTF-16 lengths differ.
|
|
return moved == self && source.utf16.elementsEqual(other.source.utf16)
|
|
}
|
|
}
|
|
|
|
private struct ComposerSelectionPayload: Decodable, Equatable {
|
|
let start: Int
|
|
let end: Int
|
|
}
|
|
|
|
private struct ComposerControlledDocumentPayload: Decodable {
|
|
let value: String
|
|
let selection: ComposerSelectionPayload?
|
|
let tokensJson: String
|
|
let mostRecentEventCount: Int
|
|
let isNativeEcho: Bool
|
|
let resetGeneration: Int
|
|
}
|
|
|
|
private struct ComposerThemePayload: Decodable {
|
|
let text: String
|
|
let placeholder: String
|
|
}
|
|
|
|
private enum ComposerEnterBehavior: String {
|
|
case send
|
|
case newline
|
|
}
|
|
|
|
private final class ComposerTextAttachment: NSTextAttachment {
|
|
let token: ComposerTokenPayload
|
|
var source: String { token.source }
|
|
var label: String { token.label }
|
|
|
|
init(token: ComposerTokenPayload, image: UIImage, size: CGSize, baselineOffset: CGFloat) {
|
|
self.token = token
|
|
super.init(data: nil, ofType: nil)
|
|
self.image = image
|
|
bounds = CGRect(x: 0, y: baselineOffset, width: size.width, height: size.height)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
nil
|
|
}
|
|
}
|
|
|
|
private final class ComposerContextAccessibilityElement: UIAccessibilityElement {
|
|
var activate: (() -> Bool)?
|
|
|
|
override func accessibilityActivate() -> Bool {
|
|
activate?() ?? false
|
|
}
|
|
}
|
|
|
|
private final class ComposerTextView: UITextView {
|
|
private static let pastedImageDirectoryName = "hanzo-composer-paste"
|
|
private static let stalePastedImageAge: TimeInterval = 60 * 60
|
|
private static let readOnlyActions = Set([
|
|
"cut:",
|
|
"delete:",
|
|
"paste:",
|
|
"redo:",
|
|
"toggleBoldface:",
|
|
"toggleItalics:",
|
|
"toggleUnderline:",
|
|
"undo:",
|
|
])
|
|
|
|
var onPasteImages: (([String]) -> Void)?
|
|
var onPasteContext: (([String: String]) -> Void)?
|
|
var onPasteText: ((String, NSRange) -> Void)?
|
|
var clipboardFragment = ""
|
|
var onSubmit: ((Bool) -> Void)?
|
|
var isReadOnly = false
|
|
var textPasteThresholdBytes = 0
|
|
var maxInputChars = Int.max
|
|
var enterBehavior: ComposerEnterBehavior = .send
|
|
/// JS supplies the actual send outcomes so the iPad Command-hold HUD names the configured actions.
|
|
var submitTitle = "Send Message"
|
|
var alternateSubmitTitle = "Send Message"
|
|
private var bypassTextPasteInterception = false
|
|
|
|
override var keyCommands: [UIKeyCommand]? {
|
|
var commands = super.keyCommands ?? []
|
|
guard !isReadOnly, markedTextRange == nil else { return commands }
|
|
if enterBehavior == .send {
|
|
let submitOnReturn = UIKeyCommand(
|
|
input: "\r",
|
|
modifierFlags: [],
|
|
action: #selector(submitMessage(_:))
|
|
)
|
|
submitOnReturn.discoverabilityTitle = submitTitle
|
|
submitOnReturn.wantsPriorityOverSystemBehavior = true
|
|
commands.append(submitOnReturn)
|
|
|
|
let submitAlternate = UIKeyCommand(
|
|
input: "\r",
|
|
modifierFlags: .command,
|
|
action: #selector(submitMessageAlternate(_:))
|
|
)
|
|
submitAlternate.discoverabilityTitle = alternateSubmitTitle
|
|
submitAlternate.wantsPriorityOverSystemBehavior = true
|
|
commands.append(submitAlternate)
|
|
|
|
let newline = UIKeyCommand(
|
|
input: "\r",
|
|
modifierFlags: .shift,
|
|
action: #selector(insertNewline(_:))
|
|
)
|
|
newline.discoverabilityTitle = "New Line"
|
|
newline.wantsPriorityOverSystemBehavior = true
|
|
commands.append(newline)
|
|
} else {
|
|
let submit = UIKeyCommand(
|
|
input: "\r",
|
|
modifierFlags: .command,
|
|
action: #selector(submitMessage(_:))
|
|
)
|
|
submit.discoverabilityTitle = submitTitle
|
|
submit.wantsPriorityOverSystemBehavior = true
|
|
commands.append(submit)
|
|
|
|
let submitAlternate = UIKeyCommand(
|
|
input: "\r",
|
|
modifierFlags: [.command, .shift],
|
|
action: #selector(submitMessageAlternate(_:))
|
|
)
|
|
submitAlternate.discoverabilityTitle = alternateSubmitTitle
|
|
submitAlternate.wantsPriorityOverSystemBehavior = true
|
|
commands.append(submitAlternate)
|
|
}
|
|
if textPasteThresholdBytes > 0 {
|
|
let pasteAsText = UIKeyCommand(
|
|
input: "v",
|
|
modifierFlags: [.command, .shift],
|
|
action: #selector(pasteInline(_:))
|
|
)
|
|
pasteAsText.discoverabilityTitle = "Paste as Text"
|
|
pasteAsText.wantsPriorityOverSystemBehavior = true
|
|
commands.append(pasteAsText)
|
|
}
|
|
return commands
|
|
}
|
|
|
|
@objc private func submitMessage(_ sender: UIKeyCommand) {
|
|
guard !isReadOnly, markedTextRange == nil else { return }
|
|
onSubmit?(false)
|
|
}
|
|
|
|
@objc private func submitMessageAlternate(_ sender: UIKeyCommand) {
|
|
guard !isReadOnly, markedTextRange == nil else { return }
|
|
onSubmit?(true)
|
|
}
|
|
|
|
@objc private func insertNewline(_ sender: UIKeyCommand) {
|
|
guard !isReadOnly, markedTextRange == nil else { return }
|
|
insertText("\n")
|
|
}
|
|
|
|
@objc private func pasteInline(_ sender: UIKeyCommand) {
|
|
guard !isReadOnly else {
|
|
return
|
|
}
|
|
bypassTextPasteInterception = true
|
|
defer { bypassTextPasteInterception = false }
|
|
paste(sender)
|
|
}
|
|
|
|
override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
|
|
if action == #selector(submitMessage(_:)) || action == #selector(insertNewline(_:)) {
|
|
return isEditable && !isReadOnly && markedTextRange == nil
|
|
}
|
|
if isReadOnly && Self.readOnlyActions.contains(NSStringFromSelector(action)) {
|
|
return false
|
|
}
|
|
if action == #selector(paste(_:)) {
|
|
let pasteboard = UIPasteboard.general
|
|
if pasteboard.hasImages ||
|
|
pasteboard.itemProviders.contains(where: {
|
|
$0.canLoadObject(ofClass: UIImage.self)
|
|
}) {
|
|
return true
|
|
}
|
|
}
|
|
return super.canPerformAction(action, withSender: sender)
|
|
}
|
|
|
|
override func canPaste(_ itemProviders: [NSItemProvider]) -> Bool {
|
|
guard isEditable, !isReadOnly else { return false }
|
|
// UIKit checks canPaste before forwarding a drag to UITextDropDelegate.
|
|
if !itemProviders.isEmpty,
|
|
itemProviders.allSatisfy({ $0.canLoadObject(ofClass: UIImage.self) }) {
|
|
return true
|
|
}
|
|
return super.canPaste(itemProviders)
|
|
}
|
|
|
|
override func paste(itemProviders: [NSItemProvider]) {
|
|
guard isEditable, !isReadOnly else { return }
|
|
if !itemProviders.isEmpty,
|
|
itemProviders.allSatisfy({ $0.canLoadObject(ofClass: UIImage.self) }) {
|
|
loadImages(from: itemProviders)
|
|
return
|
|
}
|
|
super.paste(itemProviders: itemProviders)
|
|
}
|
|
|
|
override func paste(_ sender: Any?) {
|
|
guard !isReadOnly else {
|
|
return
|
|
}
|
|
let pasteboard = UIPasteboard.general
|
|
let context = HanzoComposerClipboard.read()
|
|
if !context["fragment", default: ""].isEmpty || context["html", default: ""].contains("data-hanzo-context-fragment=") {
|
|
onPasteContext?(context)
|
|
return
|
|
}
|
|
let imageProviders = pasteboard.itemProviders.filter {
|
|
$0.canLoadObject(ofClass: UIImage.self)
|
|
}
|
|
if !imageProviders.isEmpty {
|
|
loadImages(from: imageProviders)
|
|
return
|
|
}
|
|
|
|
let images = pasteboard.images ?? []
|
|
if !images.isEmpty {
|
|
let urls = images.compactMap(Self.writeTemporaryImage)
|
|
if !urls.isEmpty {
|
|
onPasteImages?(urls)
|
|
return
|
|
}
|
|
}
|
|
// pasteboard.string is only the first item; super.paste inserts every text item.
|
|
if !bypassTextPasteInterception,
|
|
let text = pasteboard.strings?.joined(), shouldInterceptTextPaste(text) {
|
|
onPasteText?(text, selectedRange)
|
|
return
|
|
}
|
|
// read() sees only the first item; native paste keeps every item of a longer pasteboard.
|
|
if !bypassTextPasteInterception, pasteboard.numberOfItems == 1,
|
|
HanzoComposerClipboard.hasThreadLink(context["text", default: ""]) {
|
|
onPasteContext?(context)
|
|
return
|
|
}
|
|
super.paste(sender)
|
|
}
|
|
|
|
private func shouldInterceptTextPaste(_ text: String) -> Bool {
|
|
guard textPasteThresholdBytes > 0, !text.isEmpty else { return false }
|
|
let pastedLength = (text as NSString).length
|
|
if pastedLength >= textPasteThresholdBytes || text.utf8.count >= textPasteThresholdBytes {
|
|
return true
|
|
}
|
|
// Chips occupy one display character but expand to their source in the
|
|
// submitted message. Measure that source, including the replaced selection.
|
|
let sourceLength = sourceOffset(forDisplayOffset: attributedText.length)
|
|
let selectedLength = sourceOffset(forDisplayOffset: NSMaxRange(selectedRange)) -
|
|
sourceOffset(forDisplayOffset: selectedRange.location)
|
|
return sourceLength - selectedLength + pastedLength > maxInputChars
|
|
}
|
|
|
|
override func deleteBackward() {
|
|
guard !isReadOnly else {
|
|
return
|
|
}
|
|
guard selectedRange.length == 0, selectedRange.location > 0 else {
|
|
super.deleteBackward()
|
|
return
|
|
}
|
|
|
|
let previousOffset = selectedRange.location - 1
|
|
if textStorage.attribute(.attachment, at: previousOffset, effectiveRange: nil)
|
|
is ComposerTextAttachment {
|
|
replaceDisplayRange(NSRange(location: previousOffset, length: 1))
|
|
return
|
|
}
|
|
|
|
super.deleteBackward()
|
|
}
|
|
|
|
private func replaceDisplayRange(_ range: NSRange) {
|
|
guard let start = position(from: beginningOfDocument, offset: range.location),
|
|
let end = position(from: start, offset: range.length),
|
|
let textRange = textRange(from: start, to: end) else {
|
|
return
|
|
}
|
|
replace(textRange, withText: "")
|
|
}
|
|
|
|
func loadImages(from providers: [NSItemProvider]) {
|
|
let group = DispatchGroup()
|
|
let lock = NSLock()
|
|
var images = [(data: Data, fileExtension: String)?](repeating: nil, count: providers.count)
|
|
|
|
for (index, provider) in providers.enumerated() {
|
|
group.enter()
|
|
let store = { (image: (data: Data, fileExtension: String)?) in
|
|
lock.lock()
|
|
images[index] = image
|
|
lock.unlock()
|
|
group.leave()
|
|
}
|
|
let loadPNG = {
|
|
_ = provider.loadObject(ofClass: UIImage.self) { object, _ in
|
|
store((object as? UIImage)?.pngData().map { ($0, "png") })
|
|
}
|
|
}
|
|
// Decoding a GIF to UIImage keeps only its first frame, so pass its bytes through.
|
|
if provider.hasItemConformingToTypeIdentifier(UTType.gif.identifier) {
|
|
_ = provider.loadDataRepresentation(forTypeIdentifier: UTType.gif.identifier) { data, _ in
|
|
if let data { store((data, "gif")) } else { loadPNG() }
|
|
}
|
|
} else {
|
|
loadPNG()
|
|
}
|
|
}
|
|
|
|
group.notify(queue: .main) { [weak self] in
|
|
guard let self, !self.isReadOnly else {
|
|
return
|
|
}
|
|
let urls = images.compactMap { $0 }.compactMap {
|
|
Self.writeTemporaryImage($0.data, fileExtension: $0.fileExtension)
|
|
}
|
|
if !urls.isEmpty {
|
|
self.onPasteImages?(urls)
|
|
}
|
|
}
|
|
}
|
|
|
|
override func copy(_ sender: Any?) {
|
|
guard selectedRange.length > 0 else {
|
|
return super.copy(sender)
|
|
}
|
|
HanzoComposerClipboard.write(text: serializedText(in: selectedRange), fragment: clipboardFragment)
|
|
}
|
|
|
|
override func cut(_ sender: Any?) {
|
|
guard !isReadOnly else {
|
|
return
|
|
}
|
|
guard isEditable, selectedRange.length > 0 else {
|
|
return super.cut(sender)
|
|
}
|
|
copy(sender)
|
|
replaceDisplayRange(selectedRange)
|
|
}
|
|
|
|
func serializedText() -> String {
|
|
serializedText(in: NSRange(location: 0, length: attributedText.length))
|
|
}
|
|
|
|
func serializedText(in range: NSRange) -> String {
|
|
guard range.length > 0 else {
|
|
return ""
|
|
}
|
|
|
|
let source = NSMutableString()
|
|
let nsString = attributedText.string as NSString
|
|
var cursor = range.location
|
|
let end = NSMaxRange(range)
|
|
attributedText.enumerateAttribute(.attachment, in: range) { value, attachmentRange, _ in
|
|
if attachmentRange.location > cursor {
|
|
source.append(
|
|
nsString.substring(
|
|
with: NSRange(location: cursor, length: attachmentRange.location - cursor)
|
|
)
|
|
)
|
|
}
|
|
if let attachment = value as? ComposerTextAttachment {
|
|
source.append(attachment.source)
|
|
} else {
|
|
source.append(nsString.substring(with: attachmentRange))
|
|
}
|
|
cursor = NSMaxRange(attachmentRange)
|
|
}
|
|
if cursor < end {
|
|
source.append(nsString.substring(with: NSRange(location: cursor, length: end - cursor)))
|
|
}
|
|
return source as String
|
|
}
|
|
|
|
func sourceOffset(forDisplayOffset displayOffset: Int) -> Int {
|
|
let boundedOffset = max(0, min(attributedText.length, displayOffset))
|
|
if boundedOffset == 0 {
|
|
return 0
|
|
}
|
|
|
|
var sourceOffset = 0
|
|
let range = NSRange(location: 0, length: boundedOffset)
|
|
attributedText.enumerateAttribute(.attachment, in: range) { value, attributeRange, _ in
|
|
if let attachment = value as? ComposerTextAttachment {
|
|
sourceOffset += (attachment.source as NSString).length
|
|
} else {
|
|
sourceOffset += attributeRange.length
|
|
}
|
|
}
|
|
return sourceOffset
|
|
}
|
|
|
|
private static func writeTemporaryImage(_ image: UIImage) -> String? {
|
|
image.pngData().flatMap { writeTemporaryImage($0, fileExtension: "png") }
|
|
}
|
|
|
|
private static func writeTemporaryImage(_ data: Data, fileExtension: String) -> String? {
|
|
let directory = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent(pastedImageDirectoryName, isDirectory: true)
|
|
do {
|
|
try FileManager.default.createDirectory(
|
|
at: directory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
removeStaleTemporaryImages(in: directory)
|
|
let url = directory.appendingPathComponent("\(UUID().uuidString).\(fileExtension)")
|
|
try data.write(to: url, options: .atomic)
|
|
return url.absoluteString
|
|
} catch {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func removeStaleTemporaryImages(in directory: URL) {
|
|
let cutoff = Date().addingTimeInterval(-stalePastedImageAge)
|
|
guard let urls = try? FileManager.default.contentsOfDirectory(
|
|
at: directory,
|
|
includingPropertiesForKeys: [.contentModificationDateKey, .isRegularFileKey],
|
|
options: [.skipsHiddenFiles]
|
|
) else {
|
|
return
|
|
}
|
|
|
|
for url in urls {
|
|
guard
|
|
let values = try? url.resourceValues(
|
|
forKeys: [.contentModificationDateKey, .isRegularFileKey]
|
|
),
|
|
values.isRegularFile == true,
|
|
let modifiedAt = values.contentModificationDate,
|
|
modifiedAt < cutoff
|
|
else {
|
|
continue
|
|
}
|
|
try? FileManager.default.removeItem(at: url)
|
|
}
|
|
}
|
|
}
|
|
|
|
public final class HanzoComposerEditorView: ExpoView, UITextViewDelegate, UITextDropDelegate, UIGestureRecognizerDelegate {
|
|
// This view reads `layoutManager`, which otherwise swaps a live TextKit 2 view to
|
|
// TextKit 1 mid-edit; that swap can leave typed text laid out but never drawn.
|
|
private let textView = ComposerTextView(usingTextLayoutManager: false)
|
|
private let placeholderLabel = UILabel()
|
|
private var value = ""
|
|
private var tokensJson = "[]"
|
|
private var tokens: [ComposerTokenPayload] = []
|
|
private var requestedSelection: ComposerSelectionPayload?
|
|
private var theme = ComposerThemePayload(
|
|
text: "#262626",
|
|
placeholder: "#8e8e93"
|
|
)
|
|
private var fontFamily = "Zen-Regular"
|
|
private var fontSize: CGFloat = 14
|
|
private var lineHeight: CGFloat = 20
|
|
private var contentInsetVertical: CGFloat = 0
|
|
private var shouldAutoFocus = false
|
|
private var didAutoFocus = false
|
|
private var isReadOnly = false
|
|
private var isApplyingControlledValue = false
|
|
private var nativeEventCount = 0
|
|
// Count of the latest intercepted paste, so a flush can tell whether JS has received it.
|
|
private var lastPasteEventCount = 0
|
|
private var hasControlledDocument = false
|
|
private var resetGeneration = 0
|
|
private var lastContentSize = CGSize.zero
|
|
private var iconImages: [String: UIImage] = [:]
|
|
private var pendingIconUris = Set<String>()
|
|
private var tokensNeedRebuild = false
|
|
private var chipsNeedMeasuredWidth = false
|
|
private var hasDeferredForcedRebuild = false
|
|
private var pendingContentOffset: CGPoint?
|
|
private var needsSelectionReveal = false
|
|
private var selectionBeforeFocusingTap: (selection: ComposerSelectionPayload, value: String)?
|
|
|
|
let onComposerChange = EventDispatcher()
|
|
let onComposerSelectionChange = EventDispatcher()
|
|
let onComposerFocus = EventDispatcher()
|
|
let onComposerBlur = EventDispatcher()
|
|
let onComposerSubmit = EventDispatcher()
|
|
let onComposerPasteImages = EventDispatcher()
|
|
let onComposerContextPress = EventDispatcher()
|
|
let onComposerPasteContext = EventDispatcher()
|
|
let onComposerPasteText = EventDispatcher()
|
|
let onComposerContentSizeChange = EventDispatcher()
|
|
|
|
public required init(appContext: AppContext? = nil) {
|
|
super.init(appContext: appContext)
|
|
|
|
clipsToBounds = true
|
|
textView.clipsToBounds = true
|
|
textView.delegate = self
|
|
textView.textDropDelegate = self
|
|
textView.backgroundColor = .clear
|
|
textView.textContainerInset = .zero
|
|
textView.textContainer.lineFragmentPadding = 0
|
|
textView.keyboardDismissMode = .interactive
|
|
textView.alwaysBounceVertical = false
|
|
textView.showsVerticalScrollIndicator = true
|
|
textView.adjustsFontForContentSizeCategory = true
|
|
if #available(iOS 26.0, *) {
|
|
// UIKit can attach a nearby bar's scroll edge effect to this text view; its backdrop
|
|
// then draws over the typed text while the caret stays visible.
|
|
let edges = [textView.topEdgeEffect, textView.leftEdgeEffect, textView.bottomEdgeEffect, textView.rightEdgeEffect]
|
|
for edge in edges {
|
|
edge.isHidden = true
|
|
}
|
|
}
|
|
textView.onPasteImages = { [weak self] urls in
|
|
self?.onComposerPasteImages(["uris": urls])
|
|
}
|
|
textView.onPasteContext = { [weak self] context in
|
|
guard let self else { return }
|
|
let selection = self.sourceSelection()
|
|
self.nativeEventCount += 1
|
|
self.lastPasteEventCount = self.nativeEventCount
|
|
var payload: [String: Any] = context
|
|
payload["value"] = self.textView.serializedText()
|
|
payload["eventCount"] = self.nativeEventCount
|
|
payload["resetGeneration"] = self.resetGeneration
|
|
payload["selection"] = ["start": selection.start, "end": selection.end]
|
|
self.onComposerPasteContext(payload)
|
|
}
|
|
textView.onPasteText = { [weak self] text, _ in
|
|
guard let self else { return }
|
|
let selection = self.sourceSelection()
|
|
self.nativeEventCount += 1
|
|
self.lastPasteEventCount = self.nativeEventCount
|
|
self.onComposerPasteText([
|
|
"value": self.textView.serializedText(),
|
|
"eventCount": self.nativeEventCount,
|
|
"resetGeneration": self.resetGeneration,
|
|
"text": text,
|
|
"selection": ["start": selection.start, "end": selection.end],
|
|
])
|
|
}
|
|
textView.onSubmit = { [weak self] alternate in
|
|
self?.onComposerSubmit(["alternate": alternate])
|
|
}
|
|
let contextTap = UITapGestureRecognizer(target: self, action: #selector(openContext(_:)))
|
|
contextTap.cancelsTouchesInView = false
|
|
contextTap.delegate = self
|
|
textView.addGestureRecognizer(contextTap)
|
|
addSubview(textView)
|
|
|
|
placeholderLabel.numberOfLines = 0
|
|
placeholderLabel.adjustsFontForContentSizeCategory = true
|
|
addSubview(placeholderLabel)
|
|
applyTypography()
|
|
applyTheme()
|
|
}
|
|
|
|
@objc private func openContext(_ recognizer: UITapGestureRecognizer) {
|
|
guard let (index, attachment) = contextAttachment(at: recognizer.location(in: textView)) else {
|
|
textView.becomeFirstResponder()
|
|
if selectionBeforeFocusingTap != nil {
|
|
// UIKit places the caret from its own tap recognizer during this same touch.
|
|
DispatchQueue.main.async { [weak self] in
|
|
self?.restoreSelectionBeforeFocusingTap()
|
|
}
|
|
}
|
|
return
|
|
}
|
|
openContext(index: index, attachment: attachment)
|
|
}
|
|
|
|
private func openContext(index: Int, attachment: ComposerTextAttachment) {
|
|
let start = textView.sourceOffset(forDisplayOffset: index)
|
|
onComposerContextPress(["source": attachment.source, "start": start, "end": start + (attachment.source as NSString).length])
|
|
}
|
|
|
|
public override var accessibilityElements: [Any]? {
|
|
get {
|
|
var elements: [Any] = [textView]
|
|
let layout = textView.layoutManager
|
|
textView.textStorage.enumerateAttribute(.attachment, in: NSRange(location: 0, length: textView.textStorage.length)) { value, range, _ in
|
|
guard let attachment = value as? ComposerTextAttachment else { return }
|
|
let glyphRange = layout.glyphRange(forCharacterRange: range, actualCharacterRange: nil)
|
|
let rect = layout.boundingRect(forGlyphRange: glyphRange, in: textView.textContainer)
|
|
.offsetBy(dx: textView.textContainerInset.left, dy: textView.textContainerInset.top)
|
|
guard rect.intersects(textView.bounds) else { return }
|
|
let element = ComposerContextAccessibilityElement(accessibilityContainer: self)
|
|
element.accessibilityLabel = attachment.label
|
|
element.accessibilityTraits = .button
|
|
element.accessibilityFrameInContainerSpace = textView.convert(rect, to: self)
|
|
element.activate = { [weak self] in
|
|
guard let self, range.location < self.textView.textStorage.length,
|
|
self.textView.textStorage.attribute(.attachment, at: range.location, effectiveRange: nil) as? ComposerTextAttachment === attachment else { return false }
|
|
self.openContext(index: range.location, attachment: attachment)
|
|
return true
|
|
}
|
|
elements.append(element)
|
|
}
|
|
return elements
|
|
}
|
|
set { super.accessibilityElements = newValue }
|
|
}
|
|
|
|
public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
|
|
// The collapsed editor only shows the draft's first line, so a tap that expands an
|
|
// overflowing draft returns to the caret it was left at instead of moving it there.
|
|
let collapsedOverflow = !textView.isFirstResponder && !textView.isScrollEnabled && draftOverflowsBounds()
|
|
selectionBeforeFocusingTap = collapsedOverflow ? (sourceSelection(), value) : nil
|
|
return true
|
|
}
|
|
|
|
public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
|
|
true
|
|
}
|
|
|
|
public func textView(_ textView: UITextView, shouldInteractWith textAttachment: NSTextAttachment, in characterRange: NSRange, interaction: UITextItemInteraction) -> Bool {
|
|
// A chip is text context, not an image to save to the camera roll.
|
|
!(textAttachment is ComposerTextAttachment)
|
|
}
|
|
|
|
private func contextAttachment(at point: CGPoint) -> (Int, ComposerTextAttachment)? {
|
|
let containerPoint = CGPoint(x: point.x - textView.textContainerInset.left, y: point.y - textView.textContainerInset.top)
|
|
let layout = textView.layoutManager
|
|
let index = layout.characterIndex(for: containerPoint, in: textView.textContainer, fractionOfDistanceBetweenInsertionPoints: nil)
|
|
guard index < textView.textStorage.length,
|
|
let attachment = textView.textStorage.attribute(.attachment, at: index, effectiveRange: nil) as? ComposerTextAttachment else { return nil }
|
|
let glyphRange = layout.glyphRange(forCharacterRange: NSRange(location: index, length: 1), actualCharacterRange: nil)
|
|
guard layout.boundingRect(forGlyphRange: glyphRange, in: textView.textContainer).contains(containerPoint) else { return nil }
|
|
return (index, attachment)
|
|
}
|
|
|
|
public override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
let previousSize = textView.bounds.size
|
|
textView.frame = bounds
|
|
if chipsNeedMeasuredWidth, bounds.width > 0 {
|
|
chipsNeedMeasuredWidth = false
|
|
applyControlledDocument(force: true)
|
|
}
|
|
if textView.isScrollEnabled, bounds.width > 0, bounds.height > 0 {
|
|
textView.layoutIfNeeded()
|
|
if let offset = pendingContentOffset {
|
|
let minY = -textView.adjustedContentInset.top
|
|
let maxY = max(minY, textView.contentSize.height - bounds.height + textView.adjustedContentInset.bottom)
|
|
textView.setContentOffset(CGPoint(x: offset.x, y: min(maxY, max(minY, offset.y))), animated: false)
|
|
pendingContentOffset = nil
|
|
}
|
|
if needsSelectionReveal || (previousSize != bounds.size && textView.isFirstResponder) {
|
|
needsSelectionReveal = false
|
|
if let selection = textView.selectedTextRange {
|
|
textView.scrollRectToVisible(textView.caretRect(for: selection.end), animated: false)
|
|
}
|
|
}
|
|
}
|
|
let placeholderX = textView.textContainerInset.left + textView.textContainer.lineFragmentPadding
|
|
let placeholderY = textView.textContainerInset.top
|
|
let placeholderWidth = max(
|
|
0,
|
|
bounds.width - placeholderX - textView.textContainerInset.right -
|
|
textView.textContainer.lineFragmentPadding
|
|
)
|
|
placeholderLabel.frame = CGRect(
|
|
x: placeholderX,
|
|
y: placeholderY,
|
|
width: placeholderWidth,
|
|
height: max(lineHeight, placeholderLabel.font.lineHeight)
|
|
)
|
|
emitContentSizeIfNeeded()
|
|
}
|
|
|
|
func setClipboardFragment(_ fragment: String) {
|
|
textView.clipboardFragment = fragment
|
|
}
|
|
|
|
public override func didMoveToWindow() {
|
|
super.didMoveToWindow()
|
|
guard window != nil, shouldAutoFocus, !didAutoFocus else {
|
|
return
|
|
}
|
|
didAutoFocus = true
|
|
DispatchQueue.main.async { [weak self] in
|
|
self?.textView.becomeFirstResponder()
|
|
}
|
|
}
|
|
|
|
func setControlledDocumentJson(_ documentJson: String) {
|
|
guard let document = decode(ComposerControlledDocumentPayload.self, from: documentJson) else {
|
|
return
|
|
}
|
|
// A parent reset (a send clear) wins over native edits it could not see; JS drops their events
|
|
// by generation, so the revision restarts where the parent last acknowledged.
|
|
let isReset = document.resetGeneration > resetGeneration
|
|
guard isReset || document.mostRecentEventCount >= nativeEventCount else {
|
|
return
|
|
}
|
|
if isReset {
|
|
resetGeneration = document.resetGeneration
|
|
// JS drops a paste from before the reset by generation, so the flush must not wait for it.
|
|
lastPasteEventCount = 0
|
|
endComposition()
|
|
}
|
|
// iOS destroys this view under display: none and mounts a fresh one while JS keeps its
|
|
// revision and draft. Continue from them, or JS drops every event the new view sends.
|
|
nativeEventCount = document.mostRecentEventCount
|
|
if document.isNativeEcho && !isReset && hasControlledDocument && textView.serializedText() != document.value {
|
|
return
|
|
}
|
|
hasControlledDocument = true
|
|
if tokensJson != document.tokensJson {
|
|
tokensJson = document.tokensJson
|
|
let nextTokens = decode([ComposerTokenPayload].self, from: document.tokensJson) ?? []
|
|
// Rebuild only when a chip on screen would look different: typing before a chip moves its
|
|
// offsets, and Undo restores the chip it removed. A rebuild there makes iOS autocorrect
|
|
// behind the caret, and replacing the text drops UIKit's Redo.
|
|
tokensNeedRebuild = tokensNeedRebuild || !nextTokens.elementsEqual(renderedChipTokens(), by: { $0.rendersLike($1) })
|
|
tokens = nextTokens
|
|
}
|
|
let previousSelection = sourceSelection()
|
|
value = document.value
|
|
requestedSelection = document.selection
|
|
applyControlledDocument(force: tokensNeedRebuild)
|
|
applyRequestedSelection()
|
|
cancelFocusingTapRestoreIfSelectionMoved(from: previousSelection)
|
|
if tokensMatchCurrentValue() {
|
|
tokensNeedRebuild = false
|
|
}
|
|
}
|
|
|
|
func setThemeJson(_ themeJson: String) {
|
|
guard let nextTheme = decode(ComposerThemePayload.self, from: themeJson) else {
|
|
return
|
|
}
|
|
theme = nextTheme
|
|
applyTheme()
|
|
applyControlledDocument(force: true)
|
|
}
|
|
|
|
func setPlaceholder(_ placeholder: String) {
|
|
placeholderLabel.text = placeholder
|
|
textView.accessibilityLabel = placeholder
|
|
setNeedsLayout()
|
|
}
|
|
|
|
func setFontFamily(_ fontFamily: String) {
|
|
self.fontFamily = fontFamily
|
|
applyTypography()
|
|
applyControlledDocument(force: true)
|
|
}
|
|
|
|
func setFontSize(_ fontSize: CGFloat) {
|
|
self.fontSize = fontSize
|
|
applyTypography()
|
|
applyControlledDocument(force: true)
|
|
}
|
|
|
|
func setLineHeight(_ lineHeight: CGFloat) {
|
|
self.lineHeight = lineHeight
|
|
applyTypography()
|
|
applyControlledDocument(force: true)
|
|
}
|
|
|
|
func setContentInsetVertical(_ contentInsetVertical: CGFloat) {
|
|
self.contentInsetVertical = contentInsetVertical
|
|
textView.textContainerInset = UIEdgeInsets(
|
|
top: contentInsetVertical,
|
|
left: 0,
|
|
bottom: contentInsetVertical,
|
|
right: 0
|
|
)
|
|
setNeedsLayout()
|
|
}
|
|
|
|
func setEditable(_ editable: Bool) {
|
|
textView.isEditable = editable
|
|
}
|
|
|
|
func setReadOnly(_ readOnly: Bool) {
|
|
isReadOnly = readOnly
|
|
textView.isReadOnly = readOnly
|
|
}
|
|
|
|
func setScrollEnabled(_ scrollEnabled: Bool) {
|
|
guard textView.isScrollEnabled != scrollEnabled else { return }
|
|
if !scrollEnabled {
|
|
// Disabling scrolling discards UITextView's offset. Restore it after
|
|
// expansion has laid out the text, regardless of prop update order.
|
|
pendingContentOffset = pendingContentOffset ?? textView.contentOffset
|
|
}
|
|
textView.isScrollEnabled = scrollEnabled
|
|
if scrollEnabled {
|
|
revealSelectionAfterLayout()
|
|
}
|
|
}
|
|
|
|
func setAutoFocus(_ autoFocus: Bool) {
|
|
shouldAutoFocus = autoFocus
|
|
}
|
|
|
|
func setAutoCorrect(_ autoCorrect: Bool) {
|
|
textView.autocorrectionType = autoCorrect ? .yes : .no
|
|
}
|
|
|
|
func setSpellCheck(_ spellCheck: Bool) {
|
|
textView.spellCheckingType = spellCheck ? .yes : .no
|
|
}
|
|
|
|
func setEnterBehavior(_ behavior: String) {
|
|
textView.enterBehavior = ComposerEnterBehavior(rawValue: behavior) ?? .send
|
|
}
|
|
|
|
func setSubmitTitle(_ title: String) {
|
|
textView.submitTitle = title
|
|
}
|
|
|
|
func setAlternateSubmitTitle(_ title: String) {
|
|
textView.alternateSubmitTitle = title
|
|
}
|
|
|
|
func setTextPasteThresholdBytes(_ threshold: Int) {
|
|
textView.textPasteThresholdBytes = threshold
|
|
}
|
|
|
|
func setMaxInputChars(_ maxInputChars: Int) {
|
|
textView.maxInputChars = maxInputChars
|
|
}
|
|
|
|
func focusEditor() {
|
|
textView.becomeFirstResponder()
|
|
}
|
|
|
|
func blurEditor() {
|
|
textView.resignFirstResponder()
|
|
}
|
|
|
|
func readState() -> [String: Any] {
|
|
let selection = sourceSelection()
|
|
return [
|
|
"value": value,
|
|
"selection": ["start": selection.start, "end": selection.end],
|
|
"eventCount": nativeEventCount,
|
|
"resetGeneration": resetGeneration,
|
|
"pasteEventCount": lastPasteEventCount,
|
|
]
|
|
}
|
|
|
|
func setSelection(start: Int, end: Int) {
|
|
let previousSelection = sourceSelection()
|
|
requestedSelection = ComposerSelectionPayload(start: start, end: end)
|
|
applyRequestedSelection()
|
|
cancelFocusingTapRestoreIfSelectionMoved(from: previousSelection)
|
|
}
|
|
|
|
public func textViewDidChange(_ textView: UITextView) {
|
|
emitTextChange()
|
|
}
|
|
|
|
public func textViewDidChangeSelection(_ textView: UITextView) {
|
|
guard !isApplyingControlledValue else {
|
|
return
|
|
}
|
|
restoreBaseTypingAttributes()
|
|
// UIKit moves the selection before textViewDidChange runs. Emitting here
|
|
// would pair the post-edit text with a pre-edit revision counter, so let
|
|
// the change event that follows carry both; only pure caret moves emit.
|
|
guard self.textView.serializedText() == value else {
|
|
return
|
|
}
|
|
emitSelection()
|
|
}
|
|
|
|
public func textView(
|
|
_ textView: UITextView,
|
|
shouldChangeTextIn range: NSRange,
|
|
replacementText text: String
|
|
) -> Bool {
|
|
restoreBaseTypingAttributes()
|
|
return !isReadOnly
|
|
}
|
|
|
|
public func textDroppableView(
|
|
_ textDroppableView: UIView & UITextDroppable,
|
|
proposalForDrop drop: UITextDropRequest
|
|
) -> UITextDropProposal {
|
|
guard !isReadOnly else {
|
|
return UITextDropProposal(operation: .cancel)
|
|
}
|
|
guard droppedImageProviders(in: drop) != nil else {
|
|
return drop.suggestedProposal
|
|
}
|
|
|
|
// The composer owns image drops so UIKit does not insert NSTextAttachments
|
|
// that the controlled plain-text value cannot represent.
|
|
let proposal = UITextDropProposal(operation: .copy)
|
|
proposal.dropAction = .insert
|
|
proposal.dropPerformer = .delegate
|
|
return proposal
|
|
}
|
|
|
|
public func textDroppableView(
|
|
_ textDroppableView: UIView & UITextDroppable,
|
|
willPerformDrop drop: UITextDropRequest
|
|
) {
|
|
guard !isReadOnly else {
|
|
return
|
|
}
|
|
guard let imageProviders = droppedImageProviders(in: drop) else {
|
|
return
|
|
}
|
|
textView.loadImages(from: imageProviders)
|
|
}
|
|
|
|
private func droppedImageProviders(in drop: UITextDropRequest) -> [NSItemProvider]? {
|
|
let providers = drop.dropSession.items.map(\.itemProvider)
|
|
guard !providers.isEmpty,
|
|
providers.allSatisfy({ $0.canLoadObject(ofClass: UIImage.self) }) else {
|
|
return nil
|
|
}
|
|
return providers
|
|
}
|
|
|
|
public func textViewDidBeginEditing(_ textView: UITextView) {
|
|
revealSelectionAfterLayout()
|
|
onComposerFocus()
|
|
}
|
|
|
|
public func textViewDidEndEditing(_ textView: UITextView) {
|
|
onComposerBlur()
|
|
}
|
|
|
|
private func applyControlledDocument(force: Bool = false) {
|
|
// Rebuilding the attributed string tears down an active IME composition.
|
|
// Skip while marked text exists; committing the composition sends a new
|
|
// value from JS, and that update rebuilds, keeping any skipped force.
|
|
if textView.markedTextRange != nil {
|
|
hasDeferredForcedRebuild = hasDeferredForcedRebuild || force
|
|
updatePlaceholderVisibility()
|
|
return
|
|
}
|
|
let shouldForce = force || hasDeferredForcedRebuild
|
|
let currentSource = textView.serializedText()
|
|
guard shouldForce || currentSource != value || !documentMatchesExpectedTokens() else {
|
|
updatePlaceholderVisibility()
|
|
return
|
|
}
|
|
hasDeferredForcedRebuild = false
|
|
|
|
let previousSelection = sourceSelection()
|
|
if textView.isScrollEnabled {
|
|
pendingContentOffset = pendingContentOffset ?? textView.contentOffset
|
|
}
|
|
isApplyingControlledValue = true
|
|
textView.attributedText = makeAttributedDocument()
|
|
let targetSelection = requestedSelection ?? previousSelection
|
|
requestedSelection = nil
|
|
textView.selectedRange = displayRange(for: targetSelection)
|
|
restoreBaseTypingAttributes()
|
|
isApplyingControlledValue = false
|
|
if currentSource != value || previousSelection.start != targetSelection.start || previousSelection.end != targetSelection.end {
|
|
revealSelectionAfterLayout()
|
|
} else {
|
|
setNeedsLayout()
|
|
}
|
|
updatePlaceholderVisibility()
|
|
emitContentSizeIfNeeded()
|
|
}
|
|
|
|
private func endComposition() {
|
|
guard textView.markedTextRange != nil else {
|
|
return
|
|
}
|
|
isApplyingControlledValue = true
|
|
textView.unmarkText()
|
|
isApplyingControlledValue = false
|
|
}
|
|
|
|
private func makeAttributedDocument() -> NSAttributedString {
|
|
let result = NSMutableAttributedString()
|
|
let source = value as NSString
|
|
var cursor = 0
|
|
let validTokens = tokens.filter {
|
|
$0.start >= cursor &&
|
|
$0.end > $0.start &&
|
|
$0.end <= source.length &&
|
|
source.substring(with: NSRange(location: $0.start, length: $0.end - $0.start)) == $0.source
|
|
}
|
|
|
|
for token in validTokens {
|
|
if token.start < cursor {
|
|
continue
|
|
}
|
|
if token.start > cursor {
|
|
appendPlainText(
|
|
source.substring(with: NSRange(location: cursor, length: token.start - cursor)),
|
|
to: result
|
|
)
|
|
}
|
|
result.append(makeAttachmentString(token))
|
|
cursor = token.end
|
|
}
|
|
if cursor < source.length {
|
|
appendPlainText(
|
|
source.substring(with: NSRange(location: cursor, length: source.length - cursor)),
|
|
to: result
|
|
)
|
|
}
|
|
return result
|
|
}
|
|
|
|
private func appendPlainText(_ text: String, to result: NSMutableAttributedString) {
|
|
result.append(NSAttributedString(string: text, attributes: baseAttributes()))
|
|
}
|
|
|
|
private func makeAttachmentString(_ token: ComposerTokenPayload) -> NSAttributedString {
|
|
let color = token.accent.flatMap { UIColor(composerHex: $0) }
|
|
?? UIColor(composerHex: theme.text) ?? .label
|
|
let chipFont = UIFont(name: "Zen-Medium", size: fontSize)
|
|
?? UIFont.systemFont(ofSize: fontSize, weight: .medium)
|
|
let icon = token.iconUri.flatMap(iconImage(for:)).map {
|
|
token.tintsIcon == true ? Self.tinted($0, color: color) : $0
|
|
}
|
|
let image = renderChip(
|
|
label: token.label,
|
|
detail: token.detail,
|
|
icon: icon,
|
|
color: color,
|
|
font: chipFont
|
|
)
|
|
let attachment = ComposerTextAttachment(
|
|
token: token,
|
|
image: image,
|
|
size: image.size,
|
|
baselineOffset: chipFont.ascender - image.size.height
|
|
)
|
|
let attributedAttachment = NSMutableAttributedString(attachment: attachment)
|
|
attributedAttachment.addAttributes(
|
|
baseAttributes(),
|
|
range: NSRange(location: 0, length: attributedAttachment.length)
|
|
)
|
|
return attributedAttachment
|
|
}
|
|
|
|
private func renderChip(
|
|
label: String,
|
|
detail: String?,
|
|
icon: UIImage?,
|
|
color: UIColor,
|
|
font: UIFont
|
|
) -> UIImage {
|
|
let paragraph = NSMutableParagraphStyle()
|
|
paragraph.alignment = .left
|
|
paragraph.lineBreakMode = .byTruncatingMiddle
|
|
let attributedLabel = NSMutableAttributedString(
|
|
string: label,
|
|
attributes: [.font: font, .foregroundColor: color, .paragraphStyle: paragraph]
|
|
)
|
|
// The size reads as metadata, not part of the name, so it renders a step down from the
|
|
// label the way the web chip does.
|
|
if let detail, !detail.isEmpty {
|
|
let detailFont = font.withSize(font.pointSize * 0.84)
|
|
attributedLabel.append(
|
|
NSAttributedString(
|
|
string: " \(detail)",
|
|
attributes: [.font: detailFont, .foregroundColor: color, .paragraphStyle: paragraph]
|
|
)
|
|
)
|
|
}
|
|
let iconSide = font.pointSize
|
|
let iconSlot: CGFloat = icon == nil ? 0 : iconSide * 1.25
|
|
let padding: CGFloat = 5
|
|
let height = ceil(font.ascender - font.descender)
|
|
// A long path would otherwise draw a chip wider than the composer and clip. Cap the label
|
|
// to the text the editor can actually show and truncate inside it, as Android's
|
|
// `maximumWidth` does, so the chip always fits the line it sits on.
|
|
let availableWidth = textView.textContainer.size.width > 0
|
|
? textView.textContainer.size.width - textView.textContainer.lineFragmentPadding * 2
|
|
: (textView.window?.bounds.width ?? bounds.width)
|
|
if availableWidth <= 0 {
|
|
chipsNeedMeasuredWidth = true
|
|
}
|
|
let maximumLabelWidth = max(font.pointSize * 3, availableWidth - padding * 2 - iconSlot)
|
|
let labelWidth = min(attributedLabel.size().width, maximumLabelWidth)
|
|
let width = ceil(padding * 2 + iconSlot + labelWidth)
|
|
let format = UIGraphicsImageRendererFormat.preferred()
|
|
format.opaque = false
|
|
let renderer = UIGraphicsImageRenderer(size: CGSize(width: width, height: height), format: format)
|
|
return renderer.image { _ in
|
|
if let icon {
|
|
icon.draw(
|
|
in: CGRect(x: padding, y: (height - iconSide) / 2, width: iconSide, height: iconSide)
|
|
)
|
|
}
|
|
// Exactly the measured width: a spare pixel here would let a capped label draw past
|
|
// the cap instead of truncating inside it.
|
|
attributedLabel.draw(
|
|
in: CGRect(x: padding + iconSlot, y: 0, width: labelWidth, height: height)
|
|
)
|
|
}
|
|
}
|
|
|
|
private static func tinted(_ image: UIImage, color: UIColor) -> UIImage {
|
|
let format = UIGraphicsImageRendererFormat.preferred()
|
|
format.scale = image.scale
|
|
format.opaque = false
|
|
return UIGraphicsImageRenderer(size: image.size, format: format).image { _ in
|
|
color.setFill()
|
|
UIRectFill(CGRect(origin: .zero, size: image.size))
|
|
image.draw(at: .zero, blendMode: .destinationIn, alpha: 1)
|
|
}
|
|
}
|
|
|
|
private func iconImage(for uri: String) -> UIImage? {
|
|
if let image = iconImages[uri] {
|
|
return image
|
|
}
|
|
guard !pendingIconUris.contains(uri), let url = URL(string: uri) else {
|
|
return nil
|
|
}
|
|
|
|
if url.isFileURL, let image = UIImage(contentsOfFile: url.path) {
|
|
iconImages[uri] = image
|
|
return image
|
|
}
|
|
|
|
pendingIconUris.insert(uri)
|
|
URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
|
|
guard let self, let data, let image = UIImage(data: data) else {
|
|
DispatchQueue.main.async {
|
|
self?.pendingIconUris.remove(uri)
|
|
}
|
|
return
|
|
}
|
|
DispatchQueue.main.async {
|
|
self.pendingIconUris.remove(uri)
|
|
self.iconImages[uri] = image
|
|
self.applyControlledDocument(force: true)
|
|
}
|
|
}.resume()
|
|
return nil
|
|
}
|
|
|
|
private func baseAttributes() -> [NSAttributedString.Key: Any] {
|
|
let font = UIFont(name: fontFamily, size: fontSize)
|
|
?? UIFont.systemFont(ofSize: fontSize)
|
|
let paragraph = NSMutableParagraphStyle()
|
|
paragraph.minimumLineHeight = lineHeight
|
|
paragraph.maximumLineHeight = lineHeight
|
|
return [
|
|
.font: font,
|
|
.foregroundColor: UIColor(composerHex: theme.text) ?? .label,
|
|
.paragraphStyle: paragraph,
|
|
]
|
|
}
|
|
|
|
private func applyTypography() {
|
|
let font = UIFont(name: fontFamily, size: fontSize)
|
|
?? UIFont.systemFont(ofSize: fontSize)
|
|
textView.font = font
|
|
restoreBaseTypingAttributes()
|
|
placeholderLabel.font = font
|
|
setNeedsLayout()
|
|
}
|
|
|
|
private func restoreBaseTypingAttributes() {
|
|
guard textView.markedTextRange == nil else {
|
|
return
|
|
}
|
|
textView.typingAttributes = baseAttributes()
|
|
}
|
|
|
|
private func applyTheme() {
|
|
textView.textColor = UIColor(composerHex: theme.text) ?? .label
|
|
placeholderLabel.textColor = UIColor(composerHex: theme.placeholder) ?? .placeholderText
|
|
tintColor = UIColor.systemBlue
|
|
}
|
|
|
|
private func emitTextChange() {
|
|
guard !isApplyingControlledValue else {
|
|
return
|
|
}
|
|
value = textView.serializedText()
|
|
revealSelectionAfterLayout()
|
|
let selection = sourceSelection()
|
|
nativeEventCount += 1
|
|
onComposerChange([
|
|
"value": value,
|
|
"selection": ["start": selection.start, "end": selection.end],
|
|
"eventCount": nativeEventCount,
|
|
"resetGeneration": resetGeneration,
|
|
])
|
|
updatePlaceholderVisibility()
|
|
emitContentSizeIfNeeded()
|
|
}
|
|
|
|
private func emitSelection() {
|
|
// Caret moves advance the revision counter like text edits do: a
|
|
// controlled payload computed before this move is stale and must fail the
|
|
// revision guard instead of yanking the caret back mid-typing.
|
|
let currentValue = textView.serializedText()
|
|
let selection = sourceSelection()
|
|
nativeEventCount += 1
|
|
onComposerSelectionChange([
|
|
"value": currentValue,
|
|
"selection": ["start": selection.start, "end": selection.end],
|
|
"eventCount": nativeEventCount,
|
|
"resetGeneration": resetGeneration,
|
|
])
|
|
}
|
|
|
|
private func sourceSelection() -> ComposerSelectionPayload {
|
|
ComposerSelectionPayload(
|
|
start: textView.sourceOffset(forDisplayOffset: textView.selectedRange.location),
|
|
end: textView.sourceOffset(forDisplayOffset: NSMaxRange(textView.selectedRange))
|
|
)
|
|
}
|
|
|
|
private func displayRange(for selection: ComposerSelectionPayload) -> NSRange {
|
|
let start = displayOffset(forSourceOffset: selection.start)
|
|
let end = displayOffset(forSourceOffset: selection.end)
|
|
return NSRange(location: start, length: max(0, end - start))
|
|
}
|
|
|
|
private func displayOffset(forSourceOffset sourceOffset: Int) -> Int {
|
|
let boundedOffset = max(0, min((value as NSString).length, sourceOffset))
|
|
var collapsedLength = 0
|
|
for token in tokens where token.end <= boundedOffset {
|
|
collapsedLength += max(0, token.end - token.start - 1)
|
|
}
|
|
if let token = tokens.first(where: { $0.start < boundedOffset && boundedOffset < $0.end }) {
|
|
return token.start - collapsedLength + 1
|
|
}
|
|
return boundedOffset - collapsedLength
|
|
}
|
|
|
|
private func applyRequestedSelection() {
|
|
guard let requestedSelection else {
|
|
return
|
|
}
|
|
let nextRange = displayRange(for: requestedSelection)
|
|
guard nextRange.location <= textView.attributedText.length,
|
|
NSMaxRange(nextRange) <= textView.attributedText.length else {
|
|
return
|
|
}
|
|
self.requestedSelection = nil
|
|
// Programmatically assigning selectedRange resets the keyboard's
|
|
// autocorrect and predictive-text context even when the range is
|
|
// unchanged, so a no-op assignment must be skipped.
|
|
guard !NSEqualRanges(nextRange, textView.selectedRange) else {
|
|
return
|
|
}
|
|
isApplyingControlledValue = true
|
|
textView.selectedRange = nextRange
|
|
isApplyingControlledValue = false
|
|
revealSelectionAfterLayout()
|
|
}
|
|
|
|
private func restoreSelectionBeforeFocusingTap() {
|
|
guard let snapshot = selectionBeforeFocusingTap else {
|
|
return
|
|
}
|
|
selectionBeforeFocusingTap = nil
|
|
// A draft that changed during the touch, such as a transcript landing, owns the caret now.
|
|
guard textView.isFirstResponder, textView.markedTextRange == nil, value == snapshot.value else {
|
|
return
|
|
}
|
|
let range = displayRange(for: snapshot.selection)
|
|
guard !NSEqualRanges(range, textView.selectedRange) else {
|
|
return
|
|
}
|
|
textView.selectedRange = range
|
|
revealSelectionAfterLayout()
|
|
}
|
|
|
|
private func cancelFocusingTapRestoreIfSelectionMoved(from previousSelection: ComposerSelectionPayload) {
|
|
if sourceSelection() != previousSelection {
|
|
selectionBeforeFocusingTap = nil
|
|
}
|
|
}
|
|
|
|
private func draftOverflowsBounds() -> Bool {
|
|
let size = textView.sizeThatFits(CGSize(width: textView.bounds.width, height: .greatestFiniteMagnitude))
|
|
return size.height > textView.bounds.height + 1
|
|
}
|
|
|
|
private func revealSelectionAfterLayout() {
|
|
needsSelectionReveal = true
|
|
setNeedsLayout()
|
|
}
|
|
|
|
private func updatePlaceholderVisibility() {
|
|
placeholderLabel.isHidden = !value.isEmpty
|
|
}
|
|
|
|
private func emitContentSizeIfNeeded() {
|
|
guard bounds.width > 0 else { return }
|
|
// Fit independently of the animated viewport: when scrolling is disabled,
|
|
// its current height can clip TextKit's laid-out line fragments.
|
|
let fittedHeight = textView.sizeThatFits(CGSize(width: bounds.width, height: .greatestFiniteMagnitude)).height
|
|
- textView.textContainerInset.top - textView.textContainerInset.bottom
|
|
let measuredHeight = min(lineHeight * 4, fittedHeight)
|
|
let width = fittedHeight <= lineHeight + 0.5
|
|
? textView.layoutManager.usedRect(for: textView.textContainer).width
|
|
: 0
|
|
let nextSize = CGSize(width: ceil(width), height: ceil(measuredHeight))
|
|
guard abs(nextSize.width - lastContentSize.width) > 0.5 ||
|
|
abs(nextSize.height - lastContentSize.height) > 0.5 else {
|
|
return
|
|
}
|
|
lastContentSize = nextSize
|
|
onComposerContentSizeChange(["width": nextSize.width, "height": nextSize.height])
|
|
}
|
|
|
|
private func decode<T: Decodable>(_ type: T.Type, from json: String) -> T? {
|
|
guard let data = json.data(using: .utf8) else {
|
|
return nil
|
|
}
|
|
return try? JSONDecoder().decode(type, from: data)
|
|
}
|
|
|
|
private func tokensMatchCurrentValue() -> Bool {
|
|
let source = value as NSString
|
|
return tokens.allSatisfy {
|
|
$0.start >= 0 &&
|
|
$0.end > $0.start &&
|
|
$0.end <= source.length &&
|
|
source.substring(with: NSRange(location: $0.start, length: $0.end - $0.start)) == $0.source
|
|
}
|
|
}
|
|
|
|
private func renderedChipTokens() -> [ComposerTokenPayload] {
|
|
var rendered: [ComposerTokenPayload] = []
|
|
textView.textStorage.enumerateAttribute(
|
|
.attachment,
|
|
in: NSRange(location: 0, length: textView.textStorage.length)
|
|
) { value, _, _ in
|
|
if let attachment = value as? ComposerTextAttachment {
|
|
rendered.append(attachment.token)
|
|
}
|
|
}
|
|
return rendered
|
|
}
|
|
|
|
private func documentMatchesExpectedTokens() -> Bool {
|
|
let source = value as NSString
|
|
let expectedChips = tokens.compactMap { token -> (Int, String)? in
|
|
guard token.start >= 0,
|
|
token.end > token.start,
|
|
token.end <= source.length,
|
|
source.substring(
|
|
with: NSRange(location: token.start, length: token.end - token.start)
|
|
) == token.source else {
|
|
return nil
|
|
}
|
|
return (token.start, token.source)
|
|
}
|
|
var renderedChips: [(Int, String)] = []
|
|
var sourceOffset = 0
|
|
textView.attributedText.enumerateAttribute(
|
|
.attachment,
|
|
in: NSRange(location: 0, length: textView.attributedText.length)
|
|
) { value, range, _ in
|
|
if let attachment = value as? ComposerTextAttachment {
|
|
renderedChips.append((sourceOffset, attachment.source))
|
|
sourceOffset += (attachment.source as NSString).length
|
|
} else {
|
|
sourceOffset += range.length
|
|
}
|
|
}
|
|
return renderedChips.elementsEqual(expectedChips, by: ==)
|
|
}
|
|
}
|
|
|
|
private extension UIColor {
|
|
convenience init?(composerHex hex: String?) {
|
|
guard var value = hex?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
|
|
return nil
|
|
}
|
|
if value.hasPrefix("#") {
|
|
value.removeFirst()
|
|
}
|
|
guard value.count == 6 || value.count == 8,
|
|
let raw = UInt64(value, radix: 16) else {
|
|
return nil
|
|
}
|
|
if value.count == 8 {
|
|
self.init(
|
|
red: CGFloat((raw >> 24) & 0xff) / 255,
|
|
green: CGFloat((raw >> 16) & 0xff) / 255,
|
|
blue: CGFloat((raw >> 8) & 0xff) / 255,
|
|
alpha: CGFloat(raw & 0xff) / 255
|
|
)
|
|
} else {
|
|
self.init(
|
|
red: CGFloat((raw >> 16) & 0xff) / 255,
|
|
green: CGFloat((raw >> 8) & 0xff) / 255,
|
|
blue: CGFloat(raw & 0xff) / 255,
|
|
alpha: 1
|
|
)
|
|
}
|
|
}
|
|
}
|