feat: complete large-book pagination runtime and UI coverage

2026-06-03 17:47:16 +08:00
parent 584976ac5f
commit feb05eaf87
53 changed files with 6307 additions and 5126 deletions
@@ -107,6 +107,31 @@ extension RDEPUBReaderController: RDEPUBTextContentViewDelegate {

    /// 根据 EPUB 位置计算对应的页码
    func pageNumber(for location: RDEPUBLocation) -> Int? {
+        if let publication,
+           let bookPageMap = readerContext.bookPageMap,
+           let spineIndex = readerContext.normalizedSpineIndex(for: location),
+           let entry = bookPageMap.entry(forSpineIndex: spineIndex) {
+            let normalizedLocation = publication.resourceResolver.normalizedLocation(
+                location,
+                relativeToSpineIndex: nil,
+                bookIdentifier: currentBookIdentifier
+            ) ?? location
+            let localPageIndex: Int
+            if let summary = readerContext.chapterSummary(forSpineIndex: spineIndex) {
+                let offset = chapterOffset(for: normalizedLocation, fallbackEntry: entry)
+                localPageIndex = summary.pageRanges.firstIndex {
+                    let range = $0.nsRange
+                    return offset >= range.location && offset <= max(range.location + range.length - 1, range.location)
+                } ?? fallbackLocalPageIndex(for: normalizedLocation, pageCount: entry.pageCount)
+            } else {
+                localPageIndex = fallbackLocalPageIndex(for: normalizedLocation, pageCount: entry.pageCount)
+            }
+            return bookPageMap.absolutePageIndex(
+                spineIndex: spineIndex,
+                localPageIndex: min(max(localPageIndex, 0), max(entry.pageCount - 1, 0))
+            ).map { $0 + 1 }
+        }
+
        if let textBook, let publication {
            if let anchor = location.rangeAnchor?.start {
                if let page = textBook.indexTable.pageNumber(for: anchor, in: textBook) {
@@ -135,6 +160,47 @@ extension RDEPUBReaderController: RDEPUBTextContentViewDelegate {

    /// 根据页码解析对应的文本位置
    func resolvedTextLocation(forPageNumber pageNumber: Int) -> RDEPUBLocation? {
+        if let resolvedPage = resolvedRuntimePage(forPageNumber: pageNumber) {
+            let chapterLength = max(resolvedPage.chapter.typesetAttributedString.length, 1)
+            let startOffset = resolvedPage.page.pageStartOffset
+            let endOffset = max(startOffset, resolvedPage.page.pageEndOffset)
+            let fragmentID = nearestFragmentID(
+                beforeOrAt: startOffset,
+                fragmentOffsets: resolvedPage.chapter.chapterOffsetMap.fragmentOffsets
+            )
+            let location = RDEPUBLocation(
+                bookIdentifier: currentBookIdentifier,
+                href: resolvedPage.page.href,
+                progression: Double(startOffset) / Double(chapterLength),
+                lastProgression: Double(endOffset) / Double(chapterLength),
+                fragment: fragmentID,
+                rangeAnchor: RDEPUBTextRangeAnchor(
+                    start: RDEPUBTextAnchor(
+                        fileIndex: resolvedPage.page.spineIndex,
+                        row: 0,
+                        column: 0,
+                        chapterOffset: startOffset,
+                        fragmentID: fragmentID
+                    ),
+                    end: RDEPUBTextAnchor(
+                        fileIndex: resolvedPage.page.spineIndex,
+                        row: 0,
+                        column: 0,
+                        chapterOffset: endOffset,
+                        fragmentID: fragmentID
+                    )
+                )
+            )
+            if let publication {
+                return publication.resourceResolver.normalizedLocation(
+                    location,
+                    relativeToSpineIndex: nil,
+                    bookIdentifier: currentBookIdentifier
+                ) ?? location
+            }
+            return location
+        }
+
        guard let textBook,
              let publication,
              let page = textBook.page(at: pageNumber) else {
@@ -154,6 +220,17 @@ extension RDEPUBReaderController: RDEPUBTextContentViewDelegate {

    /// 同步文本阅读状态到阅读会话（页码、位置、spine、章节等）
    func synchronizeTextReadingState(pageNumber: Int, location: RDEPUBLocation) {
+        if let resolvedPage = resolvedRuntimePage(forPageNumber: pageNumber) {
+            readingSession?.updateReadingContext(
+                pageNumber: pageNumber,
+                location: location,
+                spineIndex: resolvedPage.page.spineIndex,
+                chapterIndex: resolvedPage.chapterIndex,
+                bookIdentifier: currentBookIdentifier
+            )
+            return
+        }
+
        guard let textBook,
              let page = textBook.page(at: pageNumber) else {
            readingSession?.transition(to: .idle)
@@ -184,4 +261,37 @@ extension RDEPUBReaderController: RDEPUBTextContentViewDelegate {
        }
        return (pages, chapters)
    }
+
+    private func resolvedRuntimePage(forPageNumber pageNumber: Int) -> RDEPUBResolvedPage? {
+        runtime.pageResolver.resolvePage(absolutePageIndex: pageNumber - 1)
+    }
+
+    func chapterOffset(for location: RDEPUBLocation, fallbackEntry: RDEPUBBookPageMapEntry) -> Int {
+        if let anchor = location.rangeAnchor?.start {
+            return anchor.chapterOffset
+        }
+        if let fragment = location.fragment,
+           let offset = fallbackEntry.fragmentOffsets[fragment] {
+            return offset
+        }
+        return 0
+    }
+
+    func fallbackLocalPageIndex(for location: RDEPUBLocation, pageCount: Int) -> Int {
+        guard pageCount > 1 else { return 0 }
+        return min(
+            pageCount - 1,
+            max(0, Int(round(location.navigationProgression * Double(pageCount - 1))))
+        )
+    }
+
+    private func nearestFragmentID(beforeOrAt offset: Int, fragmentOffsets: [String: Int]) -> String? {
+        var bestID: String?
+        var bestOffset = Int.min
+        for (fragmentID, fragmentOffset) in fragmentOffsets where fragmentOffset <= offset && fragmentOffset > bestOffset {
+            bestOffset = fragmentOffset
+            bestID = fragmentID
+        }
+        return bestID
+    }
 }