Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 15 additions & 1 deletion Sources/Litext/LTXLabel/LTXLabel.swift
Original file line number Diff line number Diff line change
Expand Up @@ -18,11 +18,25 @@ public class LTXLabel: LTXPlatformView, Identifiable {
// Rebuilding the layout recreates the CTFramesetter and triggers a
// full relayout; skip it when the content is unchanged.
guard !attributedText.isEqual(to: oldValue) else { return }
textLayout = LTXTextLayout(attributedString: attributedText)
let nextLayout = LTXTextLayout(attributedString: attributedText)
if let pendingPrefixUTF16Length {
nextLayout.reusePrefix(from: textLayout, utf16Length: pendingPrefixUTF16Length)
}
textLayout = nextLayout
handleRevealTextChange()
}
}

private var pendingPrefixUTF16Length: Int?

/// Updates content with a candidate unchanged prefix. The layout validates
/// attributes and paragraph boundaries before reusing immutable CoreText lines.
public func setAttributedText(_ text: NSAttributedString, preservingPrefixUTF16Length length: Int) {
pendingPrefixUTF16Length = length
defer { pendingPrefixUTF16Length = nil }
attributedText = text
}

// MARK: - Streaming reveal

/// When `true`, characters appended to `attributedText` fade in (left→right as
Expand Down
133 changes: 95 additions & 38 deletions Sources/Litext/LTXLabel/TextLayout/LTXTextLayout.swift
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,15 @@ public nonisolated class LTXTextLayout: NSObject {
private var lineOrigins: [CGPoint]?
private var lineBands: [LineBand] = []
private var hasOrderedLineBands = true
private struct PrefixSnapshot {
let lines: [CTLine]
let origins: [CGPoint]
let size: CGSize
let anchorLocation: Int
let anchorOrigin: CGPoint
}
private var prefixSnapshot: PrefixSnapshot?
private(set) var reusedLineCount = 0
private var _highlightRegions: [Int: LTXHighlightRegion]
private var cachedSuggestedSize: CGSize?
private var cachedSuggestedSizeConstraint: CGSize?
Expand Down Expand Up @@ -91,7 +100,34 @@ public nonisolated class LTXTextLayout: NSObject {

deinit {}

func reusePrefix(from previous: LTXTextLayout, utf16Length length: Int) {
guard length > 0, length <= attributedString.length,
length <= previous.attributedString.length,
previous.containerSize.width > 0,
let oldLines = previous.lines, let oldOrigins = previous.lineOrigins else { return }
let prefixRange = NSRange(location: 0, length: length)
guard attributedString.attributedSubstring(from: prefixRange).isEqual(
to: previous.attributedString.attributedSubstring(from: prefixRange)
) else { return }
let source = attributedString.string as NSString
let anchor = source.paragraphRange(for: NSRange(location: length - 1, length: 0))
// Re-layout one complete, unchanged paragraph at the join. Its baseline
// anchors paragraph spacing without independently stacking block heights.
guard NSMaxRange(anchor) <= length,
let anchorIndex = oldLines.firstIndex(where: {
CTLineGetStringRange($0).location == anchor.location
}), anchorIndex > 0 else { return }
prefixSnapshot = PrefixSnapshot(
lines: Array(oldLines[..<anchorIndex]),
origins: Array(oldOrigins[..<anchorIndex]),
size: previous.containerSize,
anchorLocation: anchor.location,
anchorOrigin: oldOrigins[anchorIndex]
)
}

public func invalidateLayout() {
prefixSnapshot = nil
cachedSuggestedSize = nil
cachedSuggestedSizeConstraint = nil
generateLayout()
Expand Down Expand Up @@ -137,6 +173,12 @@ public nonisolated class LTXTextLayout: NSObject {
drawGlyphs(in: context, glyphAlpha: glyphAlpha)
} else if let ctFrame {
CTFrameDraw(ctFrame, context)
} else {
context.textMatrix = .identity
enumerateLines { line, _, origin in
context.textPosition = origin
CTLineDraw(line, context)
}
}

processLineDrawingActions(in: context, glyphAlpha: glyphAlpha)
Expand Down Expand Up @@ -411,52 +453,67 @@ public nonisolated class LTXTextLayout: NSObject {
private func generateLayout() {
lines = nil
lineOrigins = nil
ctFrame = nil
reusedLineCount = 0
lineBands.removeAll(keepingCapacity: true)
hasOrderedLineBands = true

let containerBounds = CGRect(
origin: .zero,
size: containerSize
)
let containerPath = CGPath(
rect: containerBounds,
transform: nil
)
ctFrame = CTFramesetterCreateFrame(
framesetter,
CFRange(location: 0, length: 0),
containerPath,
nil
)

if let ctFrame {
let frameLines = CTFrameGetLines(ctFrame) as? [CTLine]
let path = CGPath(rect: CGRect(origin: .zero, size: containerSize), transform: nil)
if !generateTailLayout(path: path) {
prefixSnapshot = nil
let frame = CTFramesetterCreateFrame(framesetter, CFRange(location: 0, length: 0), path, nil)
ctFrame = frame
let frameLines = CTFrameGetLines(frame) as! [CTLine]
var origins = [CGPoint](repeating: .zero, count: frameLines.count)
if !origins.isEmpty { CTFrameGetLineOrigins(frame, CFRange(location: 0, length: 0), &origins) }
lines = frameLines

if let frameLines {
var origins = [CGPoint](repeating: .zero, count: frameLines.count)
CTFrameGetLineOrigins(ctFrame, CFRange(location: 0, length: 0), &origins)
lineOrigins = origins
lineBands.reserveCapacity(frameLines.count)
for (index, line) in frameLines.enumerated() {
var ascent: CGFloat = 0
var descent: CGFloat = 0
var leading: CGFloat = 0
CTLineGetTypographicBounds(line, &ascent, &descent, &leading)
let band = LineBand(
minY: origins[index].y - descent,
maxY: origins[index].y + ascent + leading
)
if let previous = lineBands.last,
band.minY > previous.minY || band.maxY > previous.maxY {
hasOrderedLineBands = false
}
lineBands.append(band)
}
lineOrigins = origins
}
guard let lines, let lineOrigins else { return }
lineBands.reserveCapacity(lines.count)
for (index, line) in lines.enumerated() {
var ascent: CGFloat = 0
var descent: CGFloat = 0
var leading: CGFloat = 0
CTLineGetTypographicBounds(line, &ascent, &descent, &leading)
let band = LineBand(minY: lineOrigins[index].y - descent, maxY: lineOrigins[index].y + ascent + leading)
if let previous = lineBands.last,
band.minY > previous.minY || band.maxY > previous.maxY {
hasOrderedLineBands = false
}
lineBands.append(band)
}
}

private func generateTailLayout(path: CGPath) -> Bool {
guard let prefix = prefixSnapshot, prefix.size.width == containerSize.width,
containerSize.height > 0 else { return false }
let frame = CTFramesetterCreateFrame(
framesetter, CFRange(location: prefix.anchorLocation, length: 0), path, nil
)
let visible = CTFrameGetVisibleStringRange(frame)
// Finite/truncated containers retain the full-frame implementation.
guard visible.location + visible.length == attributedString.length,
let tailLines = CTFrameGetLines(frame) as? [CTLine], !tailLines.isEmpty,
CTLineGetStringRange(tailLines[0]).location == prefix.anchorLocation else { return false }
var origins = [CGPoint](repeating: .zero, count: tailLines.count)
CTFrameGetLineOrigins(frame, CFRange(location: 0, length: 0), &origins)
let heightDelta = containerSize.height - prefix.size.height
let translation = prefix.anchorOrigin.y + heightDelta - origins[0].y
for index in origins.indices {
origins[index].y += translation
var ascent: CGFloat = 0
var descent: CGFloat = 0
CTLineGetTypographicBounds(tailLines[index], &ascent, &descent, nil)
guard origins[index].y - descent >= 0,
origins[index].y + ascent <= containerSize.height else { return false }
}
lines = prefix.lines + tailLines
lineOrigins = prefix.origins.map { CGPoint(x: $0.x, y: $0.y + heightDelta) } + origins
reusedLineCount = prefix.lines.count
return true
}

@MainActor private func extractHighlightRegions() {
guard hasHighlightAttributes else { return }
enumerateLines { line, _, lineOrigin in
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,41 @@ public extension MarkdownParser {
let document: String
var indexedContent: String?

private struct Replacement {
let original: Range<Int>
let indexed: Range<Int>
}
private var replacements: [Replacement] = []

func originalIndex(for index: String.Index, in source: String, isEnd: Bool) -> String.Index {
let offset = source.utf8.distance(from: source.startIndex, to: index)
var lower = 0
var upper = replacements.count
while lower < upper {
let middle = lower + (upper - lower) / 2
if replacements[middle].indexed.lowerBound <= offset {
lower = middle + 1
} else {
upper = middle
}
}
var originalOffset = offset
if lower > 0 {
let replacement = replacements[lower - 1]
if replacement.indexed.contains(offset) {
originalOffset = isEnd ? replacement.original.upperBound - 1 : replacement.original.lowerBound
} else {
originalOffset += replacement.original.upperBound - replacement.indexed.upperBound
}
}
let bytes = document.utf8
var position = bytes.index(bytes.startIndex, offsetBy: min(originalOffset, bytes.count))
while String.Index(position, within: document) == nil, position > bytes.startIndex {
position = bytes.index(before: position)
}
return String.Index(position, within: document)!
}

public fileprivate(set) var contents: [Int: String] = [:]

init(preprocessText: String) {
Expand All @@ -51,11 +86,12 @@ public extension MarkdownParser {
let matches = regex.matches(
in: document,
options: [],
range: NSRange(location: 0, length: document.count)
range: NSRange(location: 0, length: document.utf16.count)
).reversed()
if matches.isEmpty { return }

var indexer = 0
var substitutions: [(original: Range<Int>, length: Int)] = []
for match in matches where match.numberOfRanges > 1 {
var mathContentRange: NSRange?

Expand All @@ -81,9 +117,22 @@ public extension MarkdownParser {
contents[mathIndex] = mathContent

let replacement = MarkdownParser.replacementText(for: .math, identifier: String(mathIndex))
if let originalRange = Range(fullMatchRange, in: self.document) {
let bytes = self.document.utf8
let start = bytes.distance(from: bytes.startIndex, to: originalRange.lowerBound)
let end = bytes.distance(from: bytes.startIndex, to: originalRange.upperBound)
substitutions.append((start..<end, replacement.utf8.count))
}
document.replaceSubrange(fullRange, with: replacement)
}

var delta = 0
replacements = substitutions.reversed().map { substitution in
let start = substitution.original.lowerBound + delta
let indexed = start..<(start + substitution.length)
delta += substitution.length - substitution.original.count
return Replacement(original: substitution.original, indexed: indexed)
}
indexedContent = document
}
}
Expand Down Expand Up @@ -211,7 +260,7 @@ extension MarkdownParser {
private func processInlineMathInTextWithRegExMather(_ text: String, mathContext: MathContext) -> [MarkdownInlineNode] {
guard let regex = mathPatternWithinBlock else { return [.text(text)] }

let matches = regex.matches(in: text, options: [], range: NSRange(location: 0, length: text.count))
let matches = regex.matches(in: text, options: [], range: NSRange(location: 0, length: text.utf16.count))
if matches.isEmpty { return [.text(text)] }

var result: [MarkdownInlineNode] = []
Expand Down Expand Up @@ -248,7 +297,7 @@ extension MarkdownParser {
lastEnd = fullMatchRange.location + fullMatchRange.length
}

if lastEnd < text.count {
if lastEnd < text.utf16.count {
let remainingText = (text as NSString).substring(from: lastEnd)
if !remainingText.isEmpty {
result.append(.text(remainingText))
Expand Down
67 changes: 55 additions & 12 deletions Sources/MarkdownParser/MarkdownParser/MarkdownParser.swift
Original file line number Diff line number Diff line change
Expand Up @@ -38,27 +38,69 @@ public class MarkdownParser {
public let mathContext: [Int: String]
}

public struct RangedParseResult {
public let result: ParseResult
/// Ranges in the original source, including math before placeholder substitution.
public let blockRanges: [RootBlockRange]
}

public func parse(_ markdown: String) -> ParseResult {
parseSource(markdown, includingRanges: false).result
}

public func parseWithBlockRanges(_ markdown: String) -> RangedParseResult {
parseSource(markdown, includingRanges: true)
}

private func parseSource(_ markdown: String, includingRanges: Bool) -> RangedParseResult {
let math = MathContext(preprocessText: markdown)
math.process()
let markdown = math.indexedContent ?? markdown
let nodes = withParser { parser in
markdown.withCString { str in
cmark_parser_feed(parser, str, strlen(str))
return cmark_parser_finish(parser)
let source = math.indexedContent ?? markdown
return withParser { parser in
source.withCString { cmark_parser_feed(parser, $0, source.utf8.count) }
guard let root = cmark_parser_finish(parser) else {
assertionFailure("Unable to finish markdown parsing")
return .init(result: .init(document: [], mathContext: [:]), blockRanges: [])
}
defer { cmark_node_free(root) }
let sourceLines = includingRanges ? SourceLineIndex(source) : nil
var blocks: [MarkdownBlockNode] = []
var ranges: [RootBlockRange] = []
for child in root.children {
let context = SpecializeContext()
if let node = MarkdownBlockNode(unsafeNode: child) { context.append(node) }
let transformed = finalizeMathBlocks(context.complete(), mathContext: math)
blocks.append(contentsOf: transformed)
if let sourceLines,
let start = sourceLines.index(line: Int(child.pointee.start_line), column: Int(child.pointee.start_column)),
let end = sourceLines.index(line: Int(child.pointee.end_line), column: Int(child.pointee.end_column)) {
ranges.append(.init(
type: child.nodeType,
startIndex: math.originalIndex(for: start, in: source, isEnd: false),
endIndex: math.originalIndex(for: end, in: source, isEnd: true),
outputBlockCount: transformed.count
))
}
}
return .init(
result: .init(document: blocks, mathContext: math.contents),
blockRanges: ranges
)
}
defer { if let nodes { cmark_node_free(nodes) } }
var blocks = dumpBlocks(root: nodes)
blocks = finalizeMathBlocks(blocks, mathContext: math)
return .init(document: blocks, mathContext: math.contents)
}

public struct RootBlockRange {
public let type: MarkdownNodeType
public let startIndex: String.Index
public let endIndex: String.Index
public let outputBlockCount: Int

public init(type: MarkdownNodeType, startIndex: String.Index, endIndex: String.Index, outputBlockCount: Int) {
self.type = type
self.startIndex = startIndex
self.endIndex = endIndex
self.outputBlockCount = outputBlockCount
}
}

public struct IncrementalParseResult {
Expand Down Expand Up @@ -120,7 +162,7 @@ public class MarkdownParser {
guard !previousMarkdown.isEmpty else { return nil }
guard newMarkdown.count > previousMarkdown.count else { return nil }

let ranges = previousRanges ?? parseBlockRange(previousMarkdown)
let ranges = previousRanges ?? parseWithBlockRanges(previousMarkdown).blockRanges
guard !ranges.isEmpty else { return nil }

let tailRootBlockCount = preferredTailRootBlockCount(
Expand All @@ -147,8 +189,9 @@ public class MarkdownParser {

let tailMarkdown = String(newMarkdown[stablePrefixStartIndex...])
let mathIdentifierOffset = maxMathIdentifier(in: previousBlocks.prefix(stablePrefixBlockCount)) + 1
let tailResult = shiftMathIdentifiers(in: parse(tailMarkdown), by: mathIdentifierOffset)
let tailRanges = parseBlockRange(tailMarkdown)
let tail = parseWithBlockRanges(tailMarkdown)
let tailResult = shiftMathIdentifiers(in: tail.result, by: mathIdentifierOffset)
let tailRanges = tail.blockRanges
let shiftedTailRanges = shiftRanges(
tailRanges,
from: tailMarkdown,
Expand Down
Loading
Loading