在 Text 中实现基于关键字的搜索和定位

struct Transcription: Equatable, Identifiable {
    let id = UUID()
    let startTime: String
    var context: String
}

let transcriptions: [Transcription] = [
    .init(startTime: "06:32", context: "张老三，我问你，你的家乡在哪里"),
    .init(startTime: "08:42", context: "我的家，在山西，过河还有三百里"),
]

let regex = Regex<AnyRegexOutput>(verbatim: keyword).ignoresCase()

// 相当于
let regex = try! NSRegularExpression(pattern: keyword, options: [.caseInsensitive,.ignoreMetacharacters])

for transcription in transcriptions {
    let ranges = transcription.context.ranges(of: regex) ranges
    for range in ranges {
       ...
    }
}

@Published var count: Int // 结果数量
@Published var rangeResult: [UUID: [TranscriptionRange]] // 搜索结果 transcription.id : 结果区间和序号
@Published var currentPosition: Int? // 当前的高亮位置
@Published var positionProxy: [Int: UUID] // 结果序号 : transcription.id
var positionProxyForID: [UUID: [Int]] = [:] // transcription.id : [结果序号]

struct TranscriptionRange {
    let position: Int
    let range: Range<String.Index>
}

var text = AttributedString(transcription.context)
let lowerBound = AttributedString.Index(transcriptionRange.range.lowerBound, within: text)
let upperBound = AttributedString.Index(transcriptionRange.range.upperBound, within: text)

if ranges.currentPosition == transcriptionRange.position {
    text[lowerBound..<upperBound].swiftUI.backgroundColor = currentHighlightColor
    if bold {
        text[lowerBound..<upperBound].foundation.inlinePresentationIntent = .stronglyEmphasized
    }
} else {
    text[lowerBound..<upperBound].swiftUI.backgroundColor = highlightColor
}

List(0..<store.transcriptions.count,id:\.self) { index in
    let transcription = store.transcriptions[index]
    TranscriptionRow()
    .id(transcription.id)
}

var currentID: UUID? { // 当前高亮所在的 transcription ID ，用于 scrollTo
    guard let currentPosition else { return nil }
    return positionProxy[currentPosition]
}

.onChange(of: store.currentPosition) { [lastID = store.currentID] _ in
    let currentID = store.currentID
    if lastID != currentID {
        withAnimation {
            scrollProxy.scrollTo(currentID, anchor: .center)
        }
    }
}

func gotoPrevious() {
    if let currentPosition, currentPosition > 0 {
        self.currentPosition = currentPosition - 1
    }
}

func gotoNext() {
    if let currentPosition, currentPosition < count - 1 {
        self.currentPosition = currentPosition + 1
    }
}

/// 以当前选中的关键字为优先
private func getCurrentPositionIfSubRangeStillExist(oldRange: [UUID: [TranscriptionRange]], newRange: [UUID: [TranscriptionRange]], keyword: String, oldCurrentPosition: Int?) -> Int? {
    if let oldResult = oldRange.lazy.first(where: { $0.value.contains(where: { $0.position == oldCurrentPosition }) }),
       let oldRange = oldResult.value.first(where: { $0.position == oldCurrentPosition })?.range,
       let newResult = newRange.lazy.first(where: { $0.key == oldResult.key && $0.value.contains(where: { oldRange.overlaps($0.range) || $0.range.overlaps(oldRange) }) }),
       let newPosition = newResult.value.first(where: { oldRange.overlaps($0.range) })?.position
    {
        return newPosition
    } else {
        let nearPosition = getCurrentPositionIfInOnScreen()
        return nearPosition ?? nil
    }
}

var onScreenID: [UUID: Int] = [:] // 当前屏幕中正显示的 transcription ID

List(0..<store.transcriptions.count, id: \.self) { index in
    let transcription = store.transcriptions[index]
    TranscriptionRow()
    .onAppear { store.onScreenID[transcription.id] = index }
    .onDisappear { store.onScreenID.removeValue(forKey: transcription.id) }
    .id(transcription.id)
}

/// 从 List 当前显示中的 transcription 中就近选择 match 的 position
private func getCurrentPositionIfInOnScreen() -> Int? {
    guard let midPosition = Array(onScreenID.values).mid() else { return nil }
    let idList = onScreenID.sorted(by: { (Double($0.value) - midPosition) < (Double($1.value) - midPosition) })
    guard let id = idList.first(where: { positionProxyForID[$0.key] != nil })?.key, let position = positionProxyForID[id] else { return nil }
    guard let index = transcriptions.firstIndex(where: { $0.id == id }) else { return nil }
    if Double(index) >= midPosition {
        return position.first
    } else {
        return position.last
    }
}

let positionScheme = "goPosition" // 自定义 Schmem

text[lowerBound..<upperBound].link = URL(string: "\(positionScheme)://\(transcriptionRange.position)")

List(0..<store.transcriptions.count, id: \.self) { index in
   ...
}
.environment(\.openURL, OpenURLAction { url in
    switch url.scheme {
    case positionScheme:
        if let host = url.host(), let position = Int(host) {
            store.scrollToPosition(position)
        }
        return .handled
    default:
        return .systemAction
    }
})

@MainActor
func scrollToPosition(_ position: Int) {
    if position >= 0, position < count - 1 {
        self.currentPosition = position
    }
}

@FocusState private var focused: Bool
TextField("查找", text: $store.keyword)
    .focused($focused)
    .task {
        focused = true
    }

public extension Publisher {
    func task<T>(maxPublishers: Subscribers.Demand = .unlimited,
                 _ transform: @escaping (Output) async -> T) -> Publishers.FlatMap<Deferred<Future<T, Never>>, Self> {
        flatMap(maxPublishers: maxPublishers) { value in
            Deferred {
                Future { promise in
                    Task {
                        let output = await transform(value)
                        promise(.success(output))
                    }
                }
            }
        }
    }
}

public extension Publisher where Self.Failure == Never {
    func emptySink() -> AnyCancellable {
        sink(receiveValue: { _ in })
    }
}

cancellable = $keyword
    .removeDuplicates()
    .throttle(for: .seconds(0.1), scheduler: DispatchQueue.main, latest: true) // 使用 debounce 可能会漏掉 keyword 的最终变化
    .task(maxPublishers: .max(1)) { keyword in
        await self.search(keyword: keyword)
    }
    .emptySink()