Support realtime stream Pdf preview

[DaWangWh]

Is your feature request related to a problem? Please describe.
data of Pdf is producted by realltime, pdf preveiw is also render readltime
but the result is that preview view splash screen 。

Describe the solution you'd like
I hope preview view render smoothly at realtime mode

[dshatz]

Hi
Can you clarify please what you mean by realtime in this context?

[DaWangWh]

For example: I have two View :

1. editor view which write markdown and markdown data will transform to pdf,
2. another view is preview view which show pdf which is produced by editor view . and preview show pdf using pdfmp.

the text will changed when write markdown at editor, the pdf data also changed, the preview view will refresh at same time .
the issue is preview view splash screen .

The project is KMP project which running at mac OS .

thanks

[DaWangWh]

Feature Request: Reactive PDF Source Updates

Summary

Add support for reactive PDF source updates without recreating the entire PdfState, enabling smooth transitions when the PDF content changes dynamically.

Problem

Currently, rememberPdfState() uses pdfSource as a recomposition key, which causes the entire state to be recreated when the PDF source changes:

@Composable
fun rememberPdfState(
    pdfSource: PdfSource,
    ...
): PdfState {
    // This recreates PdfState on every pdfSource change
    val state = remember(pdfSource) { PdfState(pdfSource, ...) }
    ...
}

This causes issues in use cases where:

1. Live document editing: A Typst/LaTeX editor recompiles the document and updates the preview
2. Real-time collaboration: Multiple users editing the same document
3. Incremental updates: Small changes that should preserve scroll position and zoom level

When the PDF source changes, the current implementation:

• Destroys the entire PdfState (including scroll position, zoom level, cached pages)
• Creates a new PdfState from scratch
• Re-initializes all pages
• Causes visual flickering and loss of user context

Proposed Solution

Decouple PdfState lifetime from pdfSource changes by:

1. Single instance: Create PdfState once with remember {} (no key)
2. Reactive updates: Use LaunchedEffect(pdfSource) to trigger internal updates
3. Atomic transitions: Swap renderer internally while preserving state

@Composable
fun rememberPdfState(
    pdfSource: PdfSource,
    pageRange: IntRange = 0..Int.MAX_VALUE,
    pageSpacing: Dp = 0.dp
): PdfState {
    val scope = rememberCoroutineScope()
    val pageSpacingPx = with(LocalDensity.current) { pageSpacing.toPx().toInt() }
    
    // Create PdfState once, not tied to pdfSource
    val state = remember { PdfState(pdfSource, pageRange, pageSpacingPx, scope) }
    
    // React to pdfSource changes internally
    LaunchedEffect(pdfSource) {
        state.updatePdfSource(pdfSource)
    }
    
    state.OpenDisposableDocument()
    return state
}

Add a new internal method:

internal suspend fun updatePdfSource(newSource: PdfSource) {
    val oldRenderer = if (this::renderer.isInitialized) renderer else null
    
    withContext(Dispatchers.Default) {
        val rendererResult = PdfRendererFactory.createFromSource(newSource)
        rendererResult.mapCatching { newRenderer ->
            initPages(newRenderer).getOrThrow()
            
            // Atomic swap
            this@PdfState.renderer = newRenderer
            bufferPool = ConsumerBufferPool()
            
            // Increment version to trigger re-render
            version.value++
            
            // Clean up old renderer
            oldRenderer?.close()
        }
    }
}

Benefits

Feature	Before	After
Scroll position	Lost on update	Preserved
Zoom level	Reset to 1x	Preserved
Visual transition	Flickering	Smooth
Page cache	Destroyed	Incrementally updated
Performance	Full re-initialization	Atomic swap

Use Case: Typst Editor

@Composable
fun TypstPreview(typstSource: StateFlow<String>) {
    val pdfBytes by produceState<PdfSource?>(null, typstSource.value) {
        value = compileToPdf(typstSource.value)?.let { PdfSource.PdfBytes(it) }
    }
    
    pdfBytes?.let { source ->
        val pdfState = rememberPdfState(source)  // State preserved across updates!
        PdfView(pdfState, Modifier.fillMaxSize())
    }
}

Implementation Notes

1. Add internal val version = mutableStateOf(0) to PdfState for cache invalidation
2. Update PdfView to observe version changes and trigger re-render
3. Handle edge cases: error during update, rapid successive updates (debounce)

Breaking Changes

None. The API remains the same:

• rememberPdfState(pdfSource, pageRange, pageSpacing) signature unchanged
• Existing code continues to work

Related

This pattern is similar to how AndroidView with update callback works, or derivedStateOf - the state container is stable, but its internal content updates reactively.

[DaWangWh]

Feature Request: Reactive PDF Source Updates

Summary

Add support for reactive PDF source updates without recreating the entire PdfState, enabling smooth transitions when the PDF content changes dynamically.

Problem

Currently, rememberPdfState() uses pdfSource as a recomposition key, which causes the entire state to be recreated when the PDF source changes:

@composable
fun rememberPdfState(
pdfSource: PdfSource,
...
): PdfState {
// This recreates PdfState on every pdfSource change
val state = remember(pdfSource) { PdfState(pdfSource, ...) }
...
}
This causes issues in use cases where:

1. Live document editing: A Typst/LaTeX editor recompiles the document and updates the preview
2. Real-time collaboration: Multiple users editing the same document
3. Incremental updates: Small changes that should preserve scroll position and zoom level

When the PDF source changes, the current implementation:

• Destroys the entire PdfState (including scroll position, zoom level, cached pages)
• Creates a new PdfState from scratch
• Re-initializes all pages
• Causes visual flickering and loss of user context

Proposed Solution

Decouple PdfState lifetime from pdfSource changes by:

1. Single instance: Create PdfState once with remember {} (no key)
2. Reactive updates: Use LaunchedEffect(pdfSource) to trigger internal updates
3. Atomic transitions: Swap renderer internally while preserving state

@composable
fun rememberPdfState(
pdfSource: PdfSource,
pageRange: IntRange = 0..Int.MAX_VALUE,
pageSpacing: Dp = 0.dp
): PdfState {
val scope = rememberCoroutineScope()
val pageSpacingPx = with(LocalDensity.current) { pageSpacing.toPx().toInt() }

// Create PdfState once, not tied to pdfSource
val state = remember { PdfState(pdfSource, pageRange, pageSpacingPx, scope) }

// React to pdfSource changes internally
LaunchedEffect(pdfSource) {
    state.updatePdfSource(pdfSource)
}

state.OpenDisposableDocument()
return state

}
Add a new internal method:

internal suspend fun updatePdfSource(newSource: PdfSource) {
val oldRenderer = if (this::renderer.isInitialized) renderer else null

withContext(Dispatchers.Default) {
    val rendererResult = PdfRendererFactory.createFromSource(newSource)
    rendererResult.mapCatching { newRenderer ->
        initPages(newRenderer).getOrThrow()
        
        // Atomic swap
        this@PdfState.renderer = newRenderer
        bufferPool = ConsumerBufferPool()
        
        // Increment version to trigger re-render
        version.value++
        
        // Clean up old renderer
        oldRenderer?.close()
    }
}

}

Benefits

Feature Before After
Scroll position Lost on update Preserved
Zoom level Reset to 1x Preserved
Visual transition Flickering Smooth
Page cache Destroyed Incrementally updated
Performance Full re-initialization Atomic swap

Use Case: Typst Editor

@composable
fun TypstPreview(typstSource: StateFlow) {
val pdfBytes by produceState<PdfSource?>(null, typstSource.value) {
value = compileToPdf(typstSource.value)?.let { PdfSource.PdfBytes(it) }
}

pdfBytes?.let { source ->
    val pdfState = rememberPdfState(source)  // State preserved across updates!
    PdfView(pdfState, Modifier.fillMaxSize())
}

}

Implementation Notes

1. Add internal val version = mutableStateOf(0) to PdfState for cache invalidation
2. Update PdfView to observe version changes and trigger re-render
3. Handle edge cases: error during update, rapid successive updates (debounce)

Breaking Changes

None. The API remains the same:

• rememberPdfState(pdfSource, pageRange, pageSpacing) signature unchanged
• Existing code continues to work

Related

This pattern is similar to how AndroidView with update callback works, or derivedStateOf - the state container is stable, but its internal content updates reactively.

I try to fix the issue by using claude, but no effect.

[dshatz]

Thanks for clarifying, yeah this will require some changes.

Essentially we need to make PdfRenderer aware of the new document and seamlessly reload from there.
If you can try to hack it together, go ahead!

[dshatz]

Could you provide a small sample of how you are using pdfmp currently?