1029 lines
43 KiB
Swift
1029 lines
43 KiB
Swift
import UIKit
|
|
|
|
#if canImport(DTCoreText)
|
|
import DTCoreText
|
|
#endif
|
|
|
|
enum RDEPUBTextRendererSupport {
|
|
private static let stylesheetLinkPattern = #"<link\b[^>]*rel\s*=\s*["'][^"']*stylesheet[^"']*["'][^>]*href\s*=\s*["']([^"']+)["'][^>]*>"#
|
|
private static let imageSourcePattern = #"<img\b[^>]*src\s*=\s*["']([^"']+)["'][^>]*>"#
|
|
private static let semanticMarkerPattern = #"\$\{rd-sem-(start|end):([^}]+)\}"#
|
|
private static var didLogFootnoteAttachment = false
|
|
private static var didLogCoverAttachment = false
|
|
|
|
static func injectFragmentMarkers(into html: String) -> String {
|
|
guard let regex = try? NSRegularExpression(pattern: #"(<[^>]+\sid="([^"]+)"[^>]*>)"#, options: [.caseInsensitive]) else {
|
|
return html
|
|
}
|
|
return regex.stringByReplacingMatches(
|
|
in: html,
|
|
options: [],
|
|
range: NSRange(location: 0, length: html.utf16.count),
|
|
withTemplate: "${id=$2}$1"
|
|
)
|
|
}
|
|
|
|
static func extractFragmentOffsets(from attributedString: NSMutableAttributedString) -> [String: Int] {
|
|
let markerPattern = #"\$\{id=([^}]+)\}"#
|
|
guard let regex = try? NSRegularExpression(pattern: markerPattern, options: []) else {
|
|
return [:]
|
|
}
|
|
|
|
let mutableString = NSMutableString(string: attributedString.string)
|
|
var fragmentOffsets: [String: Int] = [:]
|
|
var searchRange = NSRange(location: 0, length: mutableString.length)
|
|
var offsetAdjustment = 0
|
|
|
|
while let match = regex.firstMatch(in: mutableString as String, options: [], range: searchRange) {
|
|
let fullMatch = mutableString.substring(with: match.range) as NSString
|
|
let fragmentID = fullMatch
|
|
.replacingOccurrences(of: #"\$\{id="#, with: "", options: .regularExpression, range: NSRange(location: 0, length: fullMatch.length))
|
|
.replacingOccurrences(of: #"\}"#, with: "", options: .regularExpression)
|
|
|
|
let adjustedLocation = max(0, match.range.location + offsetAdjustment)
|
|
fragmentOffsets[fragmentID] = adjustedLocation
|
|
attributedString.deleteCharacters(in: match.range)
|
|
mutableString.deleteCharacters(in: match.range)
|
|
offsetAdjustment -= match.range.length
|
|
searchRange = NSRange(location: match.range.location, length: mutableString.length - match.range.location)
|
|
}
|
|
|
|
return fragmentOffsets
|
|
}
|
|
|
|
static func applyPaginationSemantics(in attributedString: NSMutableAttributedString) {
|
|
guard let regex = try? NSRegularExpression(pattern: semanticMarkerPattern, options: []) else {
|
|
return
|
|
}
|
|
|
|
let mutableString = NSMutableString(string: attributedString.string)
|
|
var searchRange = NSRange(location: 0, length: mutableString.length)
|
|
var openRanges: [String: (location: Int, semantics: RDPaginationSemantics)] = [:]
|
|
|
|
while let match = regex.firstMatch(in: mutableString as String, options: [], range: searchRange) {
|
|
let kind = mutableString.substring(with: match.range(at: 1))
|
|
let payload = mutableString.substring(with: match.range(at: 2))
|
|
let markerLocation = match.range.location
|
|
|
|
attributedString.deleteCharacters(in: match.range)
|
|
mutableString.deleteCharacters(in: match.range)
|
|
|
|
if kind == "start" {
|
|
let semantics = parseSemanticMarkerPayload(payload)
|
|
openRanges[semantics.id] = (markerLocation, semantics)
|
|
} else {
|
|
let markerID = parseSemanticEndID(payload)
|
|
if let markerID, let opened = openRanges.removeValue(forKey: markerID) {
|
|
let length = max(markerLocation - opened.location, 0)
|
|
if length > 0 {
|
|
apply(semantics: opened.semantics, to: NSRange(location: opened.location, length: length), in: attributedString)
|
|
}
|
|
}
|
|
}
|
|
|
|
searchRange = NSRange(location: markerLocation, length: mutableString.length - markerLocation)
|
|
}
|
|
}
|
|
|
|
static func normalizeReadingAttributes(in attributedString: NSMutableAttributedString, style: RDEPUBTextRenderStyle) {
|
|
let fullRange = NSRange(location: 0, length: attributedString.length)
|
|
var blockIndex = 0
|
|
attributedString.enumerateAttributes(in: fullRange) { attributes, range, _ in
|
|
let sourceFont = attributes[.font] as? UIFont
|
|
let normalizedFont = normalizedFont(from: sourceFont, baseFont: style.font)
|
|
let paragraph = (attributes[.paragraphStyle] as? NSParagraphStyle)?.mutableCopy() as? NSMutableParagraphStyle ?? paragraphStyle(lineSpacing: style.lineSpacing)
|
|
paragraph.lineSpacing = style.lineSpacing
|
|
paragraph.paragraphSpacing = max(paragraph.paragraphSpacing, style.lineSpacing / 2)
|
|
|
|
var updatedAttributes = attributes
|
|
updatedAttributes[.font] = normalizedFont
|
|
updatedAttributes[.paragraphStyle] = paragraph
|
|
if let textColor = style.textColor {
|
|
updatedAttributes[.foregroundColor] = textColor
|
|
}
|
|
normalizeAttachmentDisplayIfNeeded(in: &updatedAttributes, font: normalizedFont)
|
|
updatedAttributes[.rdPageBlockRange] = NSStringFromRange(range)
|
|
updatedAttributes[.rdPageBlockIndex] = blockIndex
|
|
if let attachmentKind = attachmentKind(for: attributes) {
|
|
updatedAttributes[.rdPageAttachmentKind] = attachmentKind.rawValue
|
|
}
|
|
if let placement = normalizeAttachmentPlacement(for: attributes) {
|
|
updatedAttributes[.rdPageAttachmentPlacement] = placement.rawValue
|
|
}
|
|
if let blockKind = normalizeBlockKind(for: attributes) {
|
|
updatedAttributes[.rdPageBlockKind] = blockKind.rawValue
|
|
}
|
|
if let hints = normalizeSemanticHints(for: attributes), !hints.isEmpty {
|
|
updatedAttributes[.rdPageSemanticHints] = hints.map(\.rawValue).joined(separator: ",")
|
|
}
|
|
attributedString.setAttributes(updatedAttributes, range: range)
|
|
blockIndex += 1
|
|
}
|
|
}
|
|
|
|
static func fallbackAttributedString(for html: String, style: RDEPUBTextRenderStyle) -> NSMutableAttributedString {
|
|
let fallbackAttributes: [NSAttributedString.Key: Any] = [
|
|
.font: style.font,
|
|
.paragraphStyle: paragraphStyle(lineSpacing: style.lineSpacing),
|
|
.foregroundColor: style.textColor ?? UIColor.black
|
|
]
|
|
return NSMutableAttributedString(string: html, attributes: fallbackAttributes)
|
|
}
|
|
|
|
static func makeChapterRenderRequest(
|
|
href: String,
|
|
title: String,
|
|
rawHTML: String,
|
|
baseURL: URL?,
|
|
style: RDEPUBTextRenderStyle,
|
|
resourceResolver: RDEPUBResourceResolver?
|
|
) -> RDEPUBTextChapterRenderRequest {
|
|
let normalizedHTML = injectPaginationSemanticMarkers(into: normalizeHTML(rawHTML))
|
|
let stylesheetHrefReplacements = inlineLinkedStyleSheets(
|
|
in: normalizedHTML,
|
|
chapterHref: href,
|
|
baseURL: baseURL,
|
|
resourceResolver: resourceResolver
|
|
)
|
|
let layers = makeStyleSheetLayers(
|
|
style: style,
|
|
epubCSS: stylesheetHrefReplacements.inlinedCSS
|
|
)
|
|
let htmlWithBase = injectBaseHref(into: stylesheetHrefReplacements.html, baseURL: baseURL)
|
|
let htmlWithDefaultLayers = injectStyleTag(
|
|
into: htmlWithBase,
|
|
styleID: "rd-native-default-replace-dark",
|
|
css: layers
|
|
.filter { $0.kind != .user && $0.kind != .epub }
|
|
.map(\.css)
|
|
.joined(separator: "\n\n"),
|
|
position: .headStart
|
|
)
|
|
let htmlWithEPUBLayer = injectStyleTag(
|
|
into: htmlWithDefaultLayers,
|
|
styleID: "rd-native-epub",
|
|
css: layers.first(where: { $0.kind == .epub })?.css ?? "",
|
|
position: .headEnd
|
|
)
|
|
let composedHTML = injectStyleTag(
|
|
into: htmlWithEPUBLayer,
|
|
styleID: "rd-native-user",
|
|
css: layers.first(where: { $0.kind == .user })?.css ?? "",
|
|
position: .headEnd
|
|
)
|
|
let markedHTML = injectFragmentMarkers(into: composedHTML)
|
|
let resourceDiagnostics = stylesheetHrefReplacements.diagnostics + collectImageDiagnostics(
|
|
in: markedHTML,
|
|
chapterHref: href,
|
|
baseURL: baseURL,
|
|
resourceResolver: resourceResolver
|
|
)
|
|
|
|
let context = RDEPUBTextChapterContext(
|
|
href: href,
|
|
title: title,
|
|
html: markedHTML,
|
|
baseURL: baseURL,
|
|
stylesheet: RDEPUBTextStyleSheetPackage(layers: layers),
|
|
resourceDiagnostics: resourceDiagnostics
|
|
)
|
|
return RDEPUBTextChapterRenderRequest(context: context, style: style)
|
|
}
|
|
|
|
static func normalizeHTML(_ html: String) -> String {
|
|
var cleanedHTML = html
|
|
let replacements: [(pattern: String, template: String)] = [
|
|
(#"<hr\s+lang="zh-CN">分页符</hr>"#, ""),
|
|
(#"\r"#, "\n"),
|
|
(#"\n+"#, "\n")
|
|
]
|
|
|
|
for replacement in replacements {
|
|
if let regex = try? NSRegularExpression(pattern: replacement.pattern, options: [.caseInsensitive]) {
|
|
cleanedHTML = regex.stringByReplacingMatches(
|
|
in: cleanedHTML,
|
|
options: [],
|
|
range: NSRange(location: 0, length: cleanedHTML.utf16.count),
|
|
withTemplate: replacement.template
|
|
)
|
|
}
|
|
}
|
|
|
|
cleanedHTML = normalizeAttachmentHTMLMarkers(in: cleanedHTML)
|
|
return cleanedHTML
|
|
}
|
|
|
|
#if canImport(DTCoreText)
|
|
static func prepareHTMLElementForReaderRendering(
|
|
_ element: DTHTMLElement,
|
|
style: RDEPUBTextRenderStyle
|
|
) {
|
|
guard let attachment = element.textAttachment else { return }
|
|
|
|
let lowercasedClasses = (((attachment.attributes["class"] as? String) ?? (element.attributes["class"] as? String) ?? "")).lowercased()
|
|
let lowercasedPath = attachment.contentURL?.lastPathComponent.lowercased()
|
|
?? ((attachment.attributes["src"] as? String) ?? (element.attributes["src"] as? String) ?? "").lowercased()
|
|
let pointSize = max(element.fontDescriptor.pointSize, style.font.pointSize)
|
|
|
|
if lowercasedClasses.contains("qqreader-footnote") || lowercasedPath == "note.png" {
|
|
let targetHeight = max(round(pointSize * 0.54), 1)
|
|
let originalSize = attachment.originalSize
|
|
let aspectRatio = originalSize.height > 0 ? originalSize.width / originalSize.height : 1
|
|
let targetWidth = max(round(targetHeight * max(aspectRatio, 0.1)), 1)
|
|
attachment.displaySize = CGSize(width: targetWidth, height: targetHeight)
|
|
attachment.verticalAlignment = .center
|
|
element.displayStyle = .inline
|
|
if !didLogFootnoteAttachment {
|
|
didLogFootnoteAttachment = true
|
|
print("[EPUB][Attachment] footnote classes=\(lowercasedClasses) path=\(lowercasedPath) original=\(string(from: originalSize)) display=\(string(from: attachment.displaySize)) font=\(pointSize)")
|
|
}
|
|
return
|
|
}
|
|
|
|
if lowercasedClasses.contains("rd-front-cover-image") || lowercasedPath == "cover.jpg" {
|
|
let maxSize = UIScreen.main.bounds.insetBy(dx: 20, dy: 28).size
|
|
let originalSize = attachment.originalSize
|
|
if originalSize.width > 0, originalSize.height > 0 {
|
|
let scale = min(maxSize.width / originalSize.width, maxSize.height / originalSize.height)
|
|
attachment.displaySize = CGSize(
|
|
width: round(originalSize.width * scale),
|
|
height: round(originalSize.height * scale)
|
|
)
|
|
} else {
|
|
attachment.displaySize = CGSize(width: round(maxSize.width), height: round(maxSize.height))
|
|
}
|
|
attachment.verticalAlignment = .baseline
|
|
element.displayStyle = .block
|
|
if !didLogCoverAttachment {
|
|
didLogCoverAttachment = true
|
|
print("[EPUB][Attachment] cover classes=\(lowercasedClasses) path=\(lowercasedPath) original=\(string(from: originalSize)) display=\(string(from: attachment.displaySize))")
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
private static func makeStyleSheetLayers(
|
|
style: RDEPUBTextRenderStyle,
|
|
epubCSS: String
|
|
) -> [RDEPUBTextStyleSheetLayer] {
|
|
var layers: [RDEPUBTextStyleSheetLayer] = [
|
|
.init(kind: .default, css: defaultCSS()),
|
|
.init(kind: .replace, css: replaceCSS())
|
|
]
|
|
if isDarkTheme(style: style) {
|
|
layers.append(.init(kind: .dark, css: darkCSS(style: style)))
|
|
}
|
|
if !epubCSS.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
|
|
layers.append(.init(kind: .epub, css: epubCSS))
|
|
}
|
|
layers.append(.init(kind: .user, css: userCSS(style: style)))
|
|
return layers
|
|
}
|
|
|
|
private static func defaultCSS() -> String {
|
|
"""
|
|
html, body {
|
|
margin: 0;
|
|
padding: 0;
|
|
background: transparent;
|
|
}
|
|
body {
|
|
word-break: break-word;
|
|
overflow-wrap: break-word;
|
|
-webkit-text-size-adjust: 100%;
|
|
}
|
|
p, div, li, blockquote {
|
|
margin-top: 0;
|
|
margin-bottom: 0.75em;
|
|
}
|
|
"""
|
|
}
|
|
|
|
private static func replaceCSS() -> String {
|
|
"""
|
|
img, svg, video, canvas {
|
|
max-width: 100%;
|
|
height: auto;
|
|
}
|
|
.frontCover,
|
|
.bodyPic,
|
|
.qrbodyPic,
|
|
figure {
|
|
text-align: center;
|
|
text-indent: 0;
|
|
}
|
|
.frontCover img,
|
|
.rd-front-cover-image,
|
|
.bodyPic img,
|
|
.qrbodyPic img,
|
|
figure img {
|
|
display: block;
|
|
margin-left: auto;
|
|
margin-right: auto;
|
|
}
|
|
.qqreader-footnote,
|
|
.s-pic,
|
|
.h-pic,
|
|
.g-pic {
|
|
display: inline;
|
|
vertical-align: middle;
|
|
}
|
|
h1, h2, h3, h4, h5, h6 {
|
|
page-break-after: avoid;
|
|
break-after: avoid;
|
|
}
|
|
pre, code {
|
|
white-space: pre-wrap;
|
|
word-break: break-word;
|
|
}
|
|
table {
|
|
max-width: 100%;
|
|
}
|
|
"""
|
|
}
|
|
|
|
private static func normalizeAttachmentHTMLMarkers(in html: String) -> String {
|
|
var normalized = html
|
|
|
|
if let footnoteRegex = try? NSRegularExpression(
|
|
pattern: #"<img\b([^>]*class\s*=\s*["'][^"']*\bqqreader-footnote\b[^"']*["'][^>]*)>"#,
|
|
options: [.caseInsensitive]
|
|
) {
|
|
normalized = replaceMatches(
|
|
using: footnoteRegex,
|
|
in: normalized
|
|
) { tag in
|
|
mergeHTMLAttributes(
|
|
into: tag,
|
|
requiredClass: nil,
|
|
styleFragments: [
|
|
"width:1em",
|
|
"height:1em",
|
|
"vertical-align:middle",
|
|
"display:inline-block"
|
|
]
|
|
)
|
|
}
|
|
}
|
|
|
|
if let coverRegex = try? NSRegularExpression(
|
|
pattern: #"<h1\b([^>]*class\s*=\s*["'][^"']*\bfrontCover\b[^"']*["'][^>]*)>\s*(<img\b[^>]*>)\s*</h1>"#,
|
|
options: [.caseInsensitive]
|
|
) {
|
|
normalized = replaceMatches(
|
|
using: coverRegex,
|
|
in: normalized
|
|
) { tag in
|
|
guard let imageTagRegex = try? NSRegularExpression(pattern: #"<img\b[^>]*>"#, options: [.caseInsensitive]),
|
|
let imageMatch = imageTagRegex.firstMatch(
|
|
in: tag,
|
|
options: [],
|
|
range: NSRange(location: 0, length: (tag as NSString).length)
|
|
),
|
|
let imageRange = Range(imageMatch.range, in: tag) else {
|
|
return tag
|
|
}
|
|
|
|
let imageTag = String(tag[imageRange])
|
|
let normalizedImageTag = mergeHTMLAttributes(
|
|
into: imageTag,
|
|
requiredClass: "rd-front-cover-image",
|
|
styleFragments: [
|
|
"display:block",
|
|
"width:100%",
|
|
"height:auto",
|
|
"margin-left:auto",
|
|
"margin-right:auto"
|
|
]
|
|
)
|
|
return tag.replacingCharacters(in: imageRange, with: normalizedImageTag)
|
|
}
|
|
}
|
|
|
|
return normalized
|
|
}
|
|
|
|
private static func replaceMatches(
|
|
using regex: NSRegularExpression,
|
|
in source: String,
|
|
transform: (String) -> String
|
|
) -> String {
|
|
let nsSource = source as NSString
|
|
let matches = regex.matches(in: source, options: [], range: NSRange(location: 0, length: nsSource.length))
|
|
guard !matches.isEmpty else { return source }
|
|
|
|
var rewritten = source
|
|
for match in matches.reversed() {
|
|
guard let range = Range(match.range, in: rewritten) else { continue }
|
|
let original = String(rewritten[range])
|
|
rewritten.replaceSubrange(range, with: transform(original))
|
|
}
|
|
return rewritten
|
|
}
|
|
|
|
private static func string(from size: CGSize) -> String {
|
|
"{\(Int(round(size.width))), \(Int(round(size.height)))}"
|
|
}
|
|
|
|
private static func mergeHTMLAttributes(
|
|
into tag: String,
|
|
requiredClass: String?,
|
|
styleFragments: [String]
|
|
) -> String {
|
|
var rewritten = tag
|
|
if let requiredClass {
|
|
if let classRegex = try? NSRegularExpression(pattern: #"class\s*=\s*["']([^"']*)["']"#, options: [.caseInsensitive]),
|
|
let match = classRegex.firstMatch(in: rewritten, options: [], range: NSRange(location: 0, length: (rewritten as NSString).length)),
|
|
match.numberOfRanges > 1 {
|
|
let existingClasses = (rewritten as NSString).substring(with: match.range(at: 1))
|
|
if !existingClasses.localizedCaseInsensitiveContains(requiredClass) {
|
|
let replacement = #"class="\#(existingClasses) \#(requiredClass)""#
|
|
if let range = Range(match.range, in: rewritten) {
|
|
rewritten.replaceSubrange(range, with: replacement)
|
|
}
|
|
}
|
|
} else if let closing = rewritten.lastIndex(of: ">") {
|
|
rewritten.insert(contentsOf: #" class="\#(requiredClass)""#, at: closing)
|
|
}
|
|
}
|
|
|
|
let styleValue = styleFragments.joined(separator: ";") + ";"
|
|
if let styleRegex = try? NSRegularExpression(pattern: #"style\s*=\s*["']([^"']*)["']"#, options: [.caseInsensitive]),
|
|
let match = styleRegex.firstMatch(in: rewritten, options: [], range: NSRange(location: 0, length: (rewritten as NSString).length)),
|
|
match.numberOfRanges > 1 {
|
|
let existing = (rewritten as NSString).substring(with: match.range(at: 1)).trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let merged = existing.isEmpty ? styleValue : existing + (existing.hasSuffix(";") ? "" : ";") + styleValue
|
|
let replacement = #"style="\#(merged)""#
|
|
if let range = Range(match.range, in: rewritten) {
|
|
rewritten.replaceSubrange(range, with: replacement)
|
|
}
|
|
} else if let closing = rewritten.lastIndex(of: ">") {
|
|
rewritten.insert(contentsOf: #" style="\#(styleValue)""#, at: closing)
|
|
}
|
|
|
|
return rewritten
|
|
}
|
|
|
|
private static func normalizeAttachmentDisplayIfNeeded(
|
|
in attributes: inout [NSAttributedString.Key: Any],
|
|
font: UIFont
|
|
) {
|
|
guard let attachment = attributes[.attachment] else { return }
|
|
|
|
#if canImport(DTCoreText)
|
|
if let textAttachment = attachment as? DTTextAttachment {
|
|
let lowercasedClasses = ((textAttachment.attributes["class"] as? String) ?? "").lowercased()
|
|
let lowercasedPath = textAttachment.contentURL?.lastPathComponent.lowercased() ?? ""
|
|
if lowercasedClasses.contains("qqreader-footnote") || lowercasedPath == "note.png" {
|
|
let targetHeight = max(round(font.pointSize * 0.14), 1)
|
|
let originalSize = textAttachment.originalSize
|
|
let aspectRatio = originalSize.height > 0 ? originalSize.width / originalSize.height : 1
|
|
let targetWidth = max(round(targetHeight * max(aspectRatio, 0.1)), 1)
|
|
textAttachment.displaySize = CGSize(width: targetWidth, height: round(targetHeight))
|
|
textAttachment.verticalAlignment = .center
|
|
} else if lowercasedClasses.contains("rd-front-cover-image") {
|
|
let originalSize = textAttachment.originalSize
|
|
let maxWidth = max(UIScreen.main.bounds.width - 48, font.lineHeight * 8)
|
|
if originalSize.width > 0, originalSize.height > 0 {
|
|
let scaledHeight = round(originalSize.height * (maxWidth / originalSize.width))
|
|
textAttachment.displaySize = CGSize(width: round(maxWidth), height: scaledHeight)
|
|
} else {
|
|
textAttachment.displaySize = CGSize(width: round(maxWidth), height: round(maxWidth * 1.4))
|
|
}
|
|
textAttachment.verticalAlignment = .baseline
|
|
}
|
|
attributes[.attachment] = textAttachment
|
|
return
|
|
}
|
|
#endif
|
|
|
|
if let textAttachment = attachment as? NSTextAttachment, textAttachment.bounds.height <= 0 {
|
|
let targetHeight = max(round(font.pointSize * 0.86), 1)
|
|
textAttachment.bounds = CGRect(x: 0, y: 0, width: targetHeight, height: targetHeight)
|
|
attributes[.attachment] = textAttachment
|
|
}
|
|
}
|
|
|
|
private static func darkCSS(style: RDEPUBTextRenderStyle) -> String {
|
|
let background = style.backgroundColor?.ss_cssString ?? "rgba(0, 0, 0, 1.000)"
|
|
let text = style.textColor?.ss_cssString ?? "rgba(255, 255, 255, 1.000)"
|
|
return """
|
|
html, body {
|
|
background: \(background) !important;
|
|
color: \(text) !important;
|
|
}
|
|
a {
|
|
color: \(text) !important;
|
|
}
|
|
"""
|
|
}
|
|
|
|
private static func userCSS(style: RDEPUBTextRenderStyle) -> String {
|
|
let lineHeight = max((style.font.lineHeight + style.lineSpacing) / max(style.font.lineHeight, 1), 1)
|
|
let text = style.textColor.map { "color: \($0.ss_cssString) !important;" } ?? ""
|
|
let background = style.backgroundColor.map { "background: \($0.ss_cssString) !important;" } ?? ""
|
|
return """
|
|
html, body {
|
|
font-family: "\(style.font.familyName)" !important;
|
|
font-size: \(String(format: "%.3f", style.font.pointSize))px !important;
|
|
line-height: \(String(format: "%.3f", lineHeight)) !important;
|
|
\(text)
|
|
\(background)
|
|
}
|
|
"""
|
|
}
|
|
|
|
private static func isDarkTheme(style: RDEPUBTextRenderStyle) -> Bool {
|
|
guard let backgroundColor = style.backgroundColor else {
|
|
return false
|
|
}
|
|
var red: CGFloat = 0
|
|
var green: CGFloat = 0
|
|
var blue: CGFloat = 0
|
|
var alpha: CGFloat = 0
|
|
backgroundColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
|
|
let luminance = (0.299 * red) + (0.587 * green) + (0.114 * blue)
|
|
return luminance < 0.5
|
|
}
|
|
|
|
private static func injectBaseHref(into html: String, baseURL: URL?) -> String {
|
|
guard let baseURL else {
|
|
return html
|
|
}
|
|
let baseTag = "<base href=\"\(baseURL.absoluteString)\">"
|
|
if html.range(of: "<base ", options: [.caseInsensitive]) != nil {
|
|
return html
|
|
}
|
|
if html.range(of: "<head>", options: [.caseInsensitive]) != nil {
|
|
return html.replacingOccurrences(of: "<head>", with: "<head>\n\(baseTag)", options: [.caseInsensitive])
|
|
}
|
|
if let htmlTagRange = html.range(of: "<html", options: [.caseInsensitive]),
|
|
let htmlRange = html.range(of: ">", range: htmlTagRange.lowerBound..<html.endIndex) {
|
|
return html.replacingCharacters(in: htmlRange.upperBound..<htmlRange.upperBound, with: "\n<head>\n\(baseTag)\n</head>")
|
|
}
|
|
return "<head>\n\(baseTag)\n</head>\n" + html
|
|
}
|
|
|
|
private static func inlineLinkedStyleSheets(
|
|
in html: String,
|
|
chapterHref: String,
|
|
baseURL: URL?,
|
|
resourceResolver: RDEPUBResourceResolver?
|
|
) -> (html: String, inlinedCSS: String, diagnostics: [RDEPUBTextResourceReferenceDiagnostic]) {
|
|
guard let regex = try? NSRegularExpression(pattern: stylesheetLinkPattern, options: [.caseInsensitive]) else {
|
|
return (html, "", [])
|
|
}
|
|
|
|
let nsHTML = html as NSString
|
|
let matches = regex.matches(in: html, options: [], range: NSRange(location: 0, length: nsHTML.length))
|
|
guard !matches.isEmpty else {
|
|
return (html, "", [])
|
|
}
|
|
|
|
var rewrittenHTML = html
|
|
var inlinedCSSBlocks: [String] = []
|
|
var diagnostics: [RDEPUBTextResourceReferenceDiagnostic] = []
|
|
|
|
for match in matches.reversed() {
|
|
guard match.numberOfRanges > 1 else { continue }
|
|
let href = nsHTML.substring(with: match.range(at: 1))
|
|
let resolution = resolveReference(
|
|
href,
|
|
kind: .stylesheet,
|
|
chapterHref: chapterHref,
|
|
baseURL: baseURL,
|
|
resourceResolver: resourceResolver
|
|
)
|
|
diagnostics.append(resolution.diagnostic)
|
|
|
|
let replacement: String
|
|
if let fileURL = resolution.resolvedFileURL,
|
|
let css = try? String(contentsOf: fileURL),
|
|
resolution.diagnostic.existsOnDisk {
|
|
let cssWithResolvedURLs = rewriteCSSResourceURLs(
|
|
in: css,
|
|
styleSheetFileURL: fileURL
|
|
)
|
|
inlinedCSSBlocks.append(cssWithResolvedURLs)
|
|
replacement = ""
|
|
} else {
|
|
replacement = ""
|
|
}
|
|
|
|
if let range = Range(match.range, in: rewrittenHTML) {
|
|
rewrittenHTML.replaceSubrange(range, with: replacement)
|
|
}
|
|
}
|
|
|
|
return (rewrittenHTML, inlinedCSSBlocks.reversed().joined(separator: "\n\n"), diagnostics.reversed())
|
|
}
|
|
|
|
private static func collectImageDiagnostics(
|
|
in html: String,
|
|
chapterHref: String,
|
|
baseURL: URL?,
|
|
resourceResolver: RDEPUBResourceResolver?
|
|
) -> [RDEPUBTextResourceReferenceDiagnostic] {
|
|
guard let regex = try? NSRegularExpression(pattern: imageSourcePattern, options: [.caseInsensitive]) else {
|
|
return []
|
|
}
|
|
let nsHTML = html as NSString
|
|
return regex.matches(in: html, options: [], range: NSRange(location: 0, length: nsHTML.length)).compactMap { match in
|
|
guard match.numberOfRanges > 1 else { return nil }
|
|
let href = nsHTML.substring(with: match.range(at: 1))
|
|
return resolveReference(
|
|
href,
|
|
kind: .image,
|
|
chapterHref: chapterHref,
|
|
baseURL: baseURL,
|
|
resourceResolver: resourceResolver
|
|
).diagnostic
|
|
}
|
|
}
|
|
|
|
private static func rewriteCSSResourceURLs(
|
|
in css: String,
|
|
styleSheetFileURL: URL
|
|
) -> String {
|
|
guard let regex = try? NSRegularExpression(pattern: #"url\(([^)]+)\)"#, options: [.caseInsensitive]) else {
|
|
return css
|
|
}
|
|
|
|
let nsCSS = css as NSString
|
|
let matches = regex.matches(in: css, options: [], range: NSRange(location: 0, length: nsCSS.length))
|
|
guard !matches.isEmpty else {
|
|
return css
|
|
}
|
|
|
|
var rewrittenCSS = css
|
|
for match in matches.reversed() {
|
|
guard match.numberOfRanges > 1 else { continue }
|
|
let rawValue = nsCSS.substring(with: match.range(at: 1))
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
.trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
|
|
guard !rawValue.isEmpty else { continue }
|
|
if rawValue.hasPrefix("data:") || rawValue.hasPrefix("http://") || rawValue.hasPrefix("https://") || rawValue.hasPrefix("file://") || rawValue.hasPrefix("#") {
|
|
continue
|
|
}
|
|
guard let resolvedURL = URL(string: rawValue, relativeTo: styleSheetFileURL.deletingLastPathComponent())?.standardizedFileURL else {
|
|
continue
|
|
}
|
|
let replacement = "url(\"\(resolvedURL.absoluteString)\")"
|
|
if let range = Range(match.range, in: rewrittenCSS) {
|
|
rewrittenCSS.replaceSubrange(range, with: replacement)
|
|
}
|
|
}
|
|
return rewrittenCSS
|
|
}
|
|
|
|
private static func resolveReference(
|
|
_ reference: String,
|
|
kind: RDEPUBTextResourceReferenceKind,
|
|
chapterHref: String,
|
|
baseURL: URL?,
|
|
resourceResolver: RDEPUBResourceResolver?
|
|
) -> (normalizedHref: String?, resolvedFileURL: URL?, diagnostic: RDEPUBTextResourceReferenceDiagnostic) {
|
|
let trimmedReference = reference.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let normalizedHref = resourceResolver?.normalizedHref(trimmedReference, relativeToHref: chapterHref)
|
|
let resolvedFileURL = resourceResolver?.fileURL(forReference: trimmedReference, relativeToHref: chapterHref)
|
|
?? URL(string: trimmedReference, relativeTo: baseURL)?.standardizedFileURL
|
|
let existsOnDisk = resolvedFileURL.map { FileManager.default.fileExists(atPath: $0.path) } ?? false
|
|
let diagnostic = RDEPUBTextResourceReferenceDiagnostic(
|
|
kind: kind,
|
|
chapterHref: chapterHref,
|
|
originalReference: trimmedReference,
|
|
normalizedHref: normalizedHref,
|
|
resolvedFileURL: resolvedFileURL,
|
|
existsOnDisk: existsOnDisk
|
|
)
|
|
return (normalizedHref, resolvedFileURL, diagnostic)
|
|
}
|
|
|
|
private enum StyleInjectionPosition {
|
|
case headStart
|
|
case headEnd
|
|
}
|
|
|
|
private static func injectStyleTag(
|
|
into html: String,
|
|
styleID: String,
|
|
css: String,
|
|
position: StyleInjectionPosition
|
|
) -> String {
|
|
let trimmedCSS = css.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !trimmedCSS.isEmpty else {
|
|
return html
|
|
}
|
|
|
|
let styleTag = "<style id=\"\(styleID)\">\n\(trimmedCSS)\n</style>"
|
|
switch position {
|
|
case .headStart:
|
|
if html.range(of: "<head>", options: [.caseInsensitive]) != nil {
|
|
return html.replacingOccurrences(of: "<head>", with: "<head>\n\(styleTag)", options: [.caseInsensitive])
|
|
}
|
|
case .headEnd:
|
|
if html.range(of: "</head>", options: [.caseInsensitive]) != nil {
|
|
return html.replacingOccurrences(of: "</head>", with: "\(styleTag)\n</head>", options: [.caseInsensitive])
|
|
}
|
|
}
|
|
|
|
if html.range(of: "<body", options: [.caseInsensitive]) != nil {
|
|
return html.replacingOccurrences(of: "<body", with: "\(styleTag)\n<body", options: [.caseInsensitive])
|
|
}
|
|
return styleTag + "\n" + html
|
|
}
|
|
|
|
private static func normalizedFont(from sourceFont: UIFont?, baseFont: UIFont) -> UIFont {
|
|
guard let sourceFont else {
|
|
return baseFont
|
|
}
|
|
let traits = sourceFont.fontDescriptor.symbolicTraits.intersection([.traitBold, .traitItalic])
|
|
if let descriptor = baseFont.fontDescriptor.withSymbolicTraits(traits) {
|
|
return UIFont(descriptor: descriptor, size: baseFont.pointSize)
|
|
}
|
|
return baseFont
|
|
}
|
|
|
|
private static func paragraphStyle(lineSpacing: CGFloat) -> NSMutableParagraphStyle {
|
|
let style = NSMutableParagraphStyle()
|
|
style.lineSpacing = lineSpacing
|
|
style.paragraphSpacing = max(6, lineSpacing / 2)
|
|
return style
|
|
}
|
|
|
|
private static func attachmentKind(for attributes: [NSAttributedString.Key: Any]) -> RDEPUBTextAttachmentKind? {
|
|
if let attachment = attributes[.attachment] as? NSTextAttachment {
|
|
if attachment.image != nil || attachment.fileType?.lowercased().contains("image") == true {
|
|
return .image
|
|
}
|
|
return .generic
|
|
}
|
|
|
|
for value in attributes.values {
|
|
let typeName = String(describing: type(of: value)).lowercased()
|
|
if typeName.contains("attachment") {
|
|
return typeName.contains("image") ? .image : .generic
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
private static func injectPaginationSemanticMarkers(into html: String) -> String {
|
|
guard let regex = try? NSRegularExpression(pattern: #"<[^>]+>"#, options: [.caseInsensitive]) else {
|
|
return html
|
|
}
|
|
|
|
let nsHTML = html as NSString
|
|
let matches = regex.matches(in: html, options: [], range: NSRange(location: 0, length: nsHTML.length))
|
|
guard !matches.isEmpty else {
|
|
return html
|
|
}
|
|
|
|
var output = ""
|
|
var cursor = 0
|
|
var openTagStack: [(name: String, id: String)] = []
|
|
var nextMarkerID = 0
|
|
|
|
for match in matches {
|
|
let tagRange = match.range
|
|
guard tagRange.location >= cursor else { continue }
|
|
output += nsHTML.substring(with: NSRange(location: cursor, length: tagRange.location - cursor))
|
|
|
|
let tag = nsHTML.substring(with: tagRange)
|
|
let loweredTag = tag.lowercased()
|
|
let tagName = htmlTagName(from: loweredTag)
|
|
|
|
if loweredTag.hasPrefix("</"), let tagName {
|
|
if let index = openTagStack.lastIndex(where: { $0.name == tagName }) {
|
|
let markerID = openTagStack.remove(at: index).id
|
|
output += semanticEndMarker(id: markerID)
|
|
}
|
|
output += tag
|
|
} else if let tagName,
|
|
let semantics = paginationSemantics(forTagName: tagName, rawTag: tag) {
|
|
nextMarkerID += 1
|
|
let markerID = String(nextMarkerID)
|
|
let startMarker = semanticStartMarker(id: markerID, semantics: semantics)
|
|
if isVoidHTMLTag(tagName) || loweredTag.hasSuffix("/>") {
|
|
output += startMarker + tag + semanticEndMarker(id: markerID)
|
|
} else {
|
|
openTagStack.append((name: tagName, id: markerID))
|
|
output += tag + startMarker
|
|
}
|
|
} else {
|
|
output += tag
|
|
}
|
|
|
|
cursor = tagRange.location + tagRange.length
|
|
}
|
|
|
|
output += nsHTML.substring(from: cursor)
|
|
return output
|
|
}
|
|
|
|
private static func htmlTagName(from loweredTag: String) -> String? {
|
|
let trimmed = loweredTag.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard trimmed.hasPrefix("<") else { return nil }
|
|
let body = trimmed.dropFirst().drop(while: { $0 == "/" || $0 == "!" || $0 == "?" })
|
|
let name = body.prefix { $0.isLetter || $0.isNumber }
|
|
return name.isEmpty ? nil : String(name)
|
|
}
|
|
|
|
private static func paginationSemantics(forTagName tagName: String, rawTag: String) -> RDPaginationSemantics? {
|
|
let loweredTag = rawTag.lowercased()
|
|
let blockKind = inferredBlockKind(forTagName: tagName, rawTag: loweredTag)
|
|
let hints = inferredHints(forTagName: tagName, rawTag: loweredTag)
|
|
let placement = inferredAttachmentPlacement(forTagName: tagName, rawTag: loweredTag)
|
|
|
|
guard blockKind != nil || !hints.isEmpty || placement != nil else {
|
|
return nil
|
|
}
|
|
|
|
return RDPaginationSemantics(
|
|
id: "",
|
|
blockKind: blockKind,
|
|
hints: hints,
|
|
attachmentPlacement: placement
|
|
)
|
|
}
|
|
|
|
private static func inferredBlockKind(forTagName tagName: String, rawTag: String) -> RDEPUBTextBlockKind? {
|
|
if rawTag.contains("bodypic") || tagName == "img" || tagName == "figure" {
|
|
return .attachment
|
|
}
|
|
switch tagName {
|
|
case "blockquote":
|
|
return .blockquote
|
|
case "ul", "ol", "li":
|
|
return .list
|
|
case "table", "thead", "tbody", "tfoot", "tr", "td", "th":
|
|
return .table
|
|
case "pre", "code":
|
|
return .code
|
|
case "p":
|
|
return .paragraph
|
|
case "div":
|
|
if rawTag.contains("code") || rawTag.contains("highlight") {
|
|
return .code
|
|
}
|
|
if rawTag.contains("quote") || rawTag.contains("blockquote") {
|
|
return .blockquote
|
|
}
|
|
if rawTag.contains("table") {
|
|
return .table
|
|
}
|
|
if rawTag.contains("list") {
|
|
return .list
|
|
}
|
|
return .generic
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static func inferredHints(forTagName tagName: String, rawTag: String) -> [RDEPUBTextSemanticHint] {
|
|
var hints: [RDEPUBTextSemanticHint] = []
|
|
if rawTag.contains("avoidpagebreakinside") ||
|
|
rawTag.contains("break-inside: avoid") ||
|
|
rawTag.contains("page-break-inside: avoid") ||
|
|
["blockquote", "pre", "code", "table", "ul", "ol"].contains(tagName) {
|
|
hints.append(.avoidPageBreakInside)
|
|
}
|
|
if rawTag.contains("pagebreakbefore") ||
|
|
rawTag.contains("page-break-before: always") ||
|
|
rawTag.contains("break-before: page") {
|
|
hints.append(.pageBreakBefore)
|
|
}
|
|
if rawTag.contains("pagebreakafter") ||
|
|
rawTag.contains("page-break-after: always") ||
|
|
rawTag.contains("break-after: page") {
|
|
hints.append(.pageBreakAfter)
|
|
}
|
|
if rawTag.contains("pageRelate".lowercased()) || rawTag.contains("weread-page-relate") {
|
|
hints.append(.pageRelate)
|
|
}
|
|
return hints
|
|
.reduce(into: [RDEPUBTextSemanticHint]()) { result, hint in
|
|
if !result.contains(hint) {
|
|
result.append(hint)
|
|
}
|
|
}
|
|
.sorted { $0.rawValue < $1.rawValue }
|
|
}
|
|
|
|
private static func inferredAttachmentPlacement(forTagName tagName: String, rawTag: String) -> RDEPUBTextAttachmentPlacement? {
|
|
guard tagName == "img" || rawTag.contains("bodypic") || rawTag.contains("wr-vertical-center") else {
|
|
return nil
|
|
}
|
|
if rawTag.contains("wr-vertical-center-style: 2") || rawTag.contains("bodypic") {
|
|
return .centered
|
|
}
|
|
if rawTag.contains("wr-vertical-center-style: 1") || rawTag.contains("wr-vertical-center") {
|
|
return .baseline
|
|
}
|
|
return .inline
|
|
}
|
|
|
|
private static func isVoidHTMLTag(_ tagName: String) -> Bool {
|
|
["img", "br", "hr", "input", "meta", "link"].contains(tagName)
|
|
}
|
|
|
|
private static func semanticStartMarker(id: String, semantics: RDPaginationSemantics) -> String {
|
|
var segments = ["id=\(id)"]
|
|
if let blockKind = semantics.blockKind {
|
|
segments.append("block=\(blockKind.rawValue)")
|
|
}
|
|
if !semantics.hints.isEmpty {
|
|
segments.append("hints=\(semantics.hints.map(\.rawValue).joined(separator: ","))")
|
|
}
|
|
if let placement = semantics.attachmentPlacement {
|
|
segments.append("placement=\(placement.rawValue)")
|
|
}
|
|
return "${rd-sem-start:\(segments.joined(separator: ";"))}"
|
|
}
|
|
|
|
private static func semanticEndMarker(id: String) -> String {
|
|
"${rd-sem-end:id=\(id)}"
|
|
}
|
|
|
|
private static func parseSemanticMarkerPayload(_ payload: String) -> RDPaginationSemantics {
|
|
var values: [String: String] = [:]
|
|
payload.split(separator: ";").forEach { entry in
|
|
let parts = entry.split(separator: "=", maxSplits: 1)
|
|
guard parts.count == 2 else { return }
|
|
values[String(parts[0])] = String(parts[1])
|
|
}
|
|
let blockKind = values["block"].flatMap(RDEPUBTextBlockKind.init(rawValue:))
|
|
let hints = values["hints"]?
|
|
.split(separator: ",")
|
|
.compactMap { RDEPUBTextSemanticHint(rawValue: String($0)) } ?? []
|
|
let placement = values["placement"].flatMap(RDEPUBTextAttachmentPlacement.init(rawValue:))
|
|
return RDPaginationSemantics(
|
|
id: values["id"] ?? UUID().uuidString,
|
|
blockKind: blockKind,
|
|
hints: hints,
|
|
attachmentPlacement: placement
|
|
)
|
|
}
|
|
|
|
private static func parseSemanticEndID(_ payload: String) -> String? {
|
|
payload.split(separator: ";").first { $0.hasPrefix("id=") }.map { String($0.dropFirst(3)) }
|
|
}
|
|
|
|
private static func apply(
|
|
semantics: RDPaginationSemantics,
|
|
to range: NSRange,
|
|
in attributedString: NSMutableAttributedString
|
|
) {
|
|
var attributes: [NSAttributedString.Key: Any] = [:]
|
|
if let blockKind = semantics.blockKind {
|
|
attributes[.rdPageBlockKind] = blockKind.rawValue
|
|
}
|
|
if !semantics.hints.isEmpty {
|
|
attributes[.rdPageSemanticHints] = semantics.hints.map(\.rawValue).joined(separator: ",")
|
|
}
|
|
if let placement = semantics.attachmentPlacement {
|
|
attributes[.rdPageAttachmentPlacement] = placement.rawValue
|
|
}
|
|
guard !attributes.isEmpty else { return }
|
|
attributedString.addAttributes(attributes, range: range)
|
|
}
|
|
|
|
private static func normalizeBlockKind(for attributes: [NSAttributedString.Key: Any]) -> RDEPUBTextBlockKind? {
|
|
if let rawValue = attributes[.rdPageBlockKind] as? String,
|
|
let blockKind = RDEPUBTextBlockKind(rawValue: rawValue) {
|
|
return blockKind
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func normalizeSemanticHints(for attributes: [NSAttributedString.Key: Any]) -> [RDEPUBTextSemanticHint]? {
|
|
if let rawValue = attributes[.rdPageSemanticHints] as? String {
|
|
let hints = rawValue
|
|
.split(separator: ",")
|
|
.compactMap { RDEPUBTextSemanticHint(rawValue: String($0)) }
|
|
return hints.isEmpty ? nil : hints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func normalizeAttachmentPlacement(for attributes: [NSAttributedString.Key: Any]) -> RDEPUBTextAttachmentPlacement? {
|
|
if let rawValue = attributes[.rdPageAttachmentPlacement] as? String,
|
|
let placement = RDEPUBTextAttachmentPlacement(rawValue: rawValue) {
|
|
return placement
|
|
}
|
|
if let attachmentKind = attachmentKind(for: attributes), attachmentKind == .image {
|
|
return .inline
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private struct RDPaginationSemantics {
|
|
var id: String
|
|
var blockKind: RDEPUBTextBlockKind?
|
|
var hints: [RDEPUBTextSemanticHint]
|
|
var attachmentPlacement: RDEPUBTextAttachmentPlacement?
|
|
}
|
|
}
|