react-native-pdfrender 0.1.0

package/android/src/main/java/com/pdfrender/PdfViewerFabricManager.kt

@@ -0,0 +1,244 @@
+package com.pdfrender
+
+import android.net.Uri
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material.MaterialTheme
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.compose.ui.unit.dp
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.pdfrender.events.FullScreenChangeEvent
+import com.pdfrender.events.LeftScreenChangeEvent
+import com.pdfrender.events.RightScreenChangeEvent
+import com.pdfrender.events.ZoomChangeEvent
+
+/**
+ * PdfViewerFabricManager — New Architecture ViewManager
+ *
+ * Replaces the old PdfViewerViewManager (which used RCTEventEmitter).
+ * Now uses UIManagerHelper.getEventDispatcherForReactTag() — the correct
+ * event dispatch path for both Fabric and the interop bridge.
+ *
+ * Each @ReactProp setter stores the value in the view's tag map so that
+ * updateViewContent() can compose a complete snapshot even when props
+ * arrive in separate calls.
+ */
+class PdfViewerFabricManager : SimpleViewManager<ComposeView>() {
+
+    override fun getName(): String = VIEW_NAME
+
+    // ── Tag keys for storing per-view prop state ─────────────────────────────
+    // Using string-keyed tags via setTag(key, value) on ComposeView.
+    // Each view instance carries its own snapshot — no shared state.
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ComposeView =
+        ComposeView(reactContext).apply {
+            clipToOutline = true
+            clipToPadding = true
+            clipChildren = true
+            // Dispose Compose when the view is detached from the window tree.
+            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+        }
+
+    // ── Prop setters ─────────────────────────────────────────────────────────
+
+    @ReactProp(name = "pdfUri")
+    fun setPdfUri(view: ComposeView, uri: String?) {
+        view.setTag(R.id.tag_pdf_uri, uri)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "initialPageIndex", defaultInt = -1)
+    fun setInitialPageIndex(view: ComposeView, index: Int) {
+        view.setTag(R.id.tag_page_index, index)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "maxWidth")
+    fun setMaxWidth(view: ComposeView, maxWidth: Float) {
+        view.setTag(R.id.tag_max_width, maxWidth)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "screenWidthPercentage", defaultFloat = 100f)
+    fun setScreenWidthPercentage(view: ComposeView, percentage: Float) {
+        view.setTag(R.id.tag_screen_pct, percentage)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "defaultZoom", defaultFloat = 1.5f)
+    fun setDefaultZoom(view: ComposeView, zoom: Float) {
+        view.setTag(R.id.tag_default_zoom, zoom)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "isFullScreen", defaultBoolean = false)
+    fun setIsFullScreen(view: ComposeView, isFullScreen: Boolean) {
+        view.setTag(R.id.tag_fullscreen, isFullScreen)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "rightLayout", defaultBoolean = false)
+    fun setRightLayout(view: ComposeView, rightLayout: Boolean) {
+        view.setTag(R.id.tag_right_layout, rightLayout)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "backButtonText")
+    fun setBackButtonText(view: ComposeView, text: String?) {
+        view.setTag(R.id.tag_back_text, text)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "headerText")
+    fun setHeaderText(view: ComposeView, text: String?) {
+        view.setTag(R.id.tag_header_text, text)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "iconUrls")
+    fun setIconUrls(view: ComposeView, iconUrls: ReadableMap?) {
+        view.setTag(R.id.tag_icon_urls, iconUrls)
+        updateViewContent(view)
+    }
+
+    @ReactProp(name = "iconStyle")
+    fun setIconStyle(view: ComposeView, iconStyle: ReadableMap?) {
+        view.setTag(R.id.tag_icon_style, iconStyle)
+        updateViewContent(view)
+    }
+
+    // ── Compose content update ───────────────────────────────────────────────
+
+    private fun updateViewContent(view: ComposeView) {
+        val uriString = view.getTag(R.id.tag_pdf_uri) as? String
+        if (uriString.isNullOrEmpty()) return
+
+        val uri              = Uri.parse(uriString)
+        val pageIndex        = (view.getTag(R.id.tag_page_index) as? Int) ?: -1
+        val maxWidthPx       = view.getTag(R.id.tag_max_width) as? Float
+        val screenPct        = (view.getTag(R.id.tag_screen_pct) as? Float) ?: 100f
+        val defaultZoom      = (view.getTag(R.id.tag_default_zoom) as? Float) ?: 1.5f
+        val isFullScreen     = (view.getTag(R.id.tag_fullscreen) as? Boolean) ?: false
+        val rightLayout      = (view.getTag(R.id.tag_right_layout) as? Boolean) ?: false
+        val backButtonText   = view.getTag(R.id.tag_back_text) as? String
+        val headerText       = view.getTag(R.id.tag_header_text) as? String
+        val iconUrlsMap      = view.getTag(R.id.tag_icon_urls) as? ReadableMap
+        val iconStyleMap     = view.getTag(R.id.tag_icon_style) as? ReadableMap
+
+        val iconUrls: Map<String, String?>? = iconUrlsMap?.let { map ->
+            mapOf(
+                "zoomIn"        to map.takeIf { it.hasKey("zoomIn") }?.getString("zoomIn"),
+                "zoomOut"       to map.takeIf { it.hasKey("zoomOut") }?.getString("zoomOut"),
+                "fullScreen"    to map.takeIf { it.hasKey("fullScreen") }?.getString("fullScreen"),
+                "minimizeScreen" to map.takeIf { it.hasKey("minimizeScreen") }?.getString("minimizeScreen"),
+                "leftLayout"    to map.takeIf { it.hasKey("leftLayout") }?.getString("leftLayout"),
+                "rightLayout"   to map.takeIf { it.hasKey("rightLayout") }?.getString("rightLayout")
+            )
+        }
+
+        val iconSizeDp: androidx.compose.ui.unit.Dp = iconStyleMap
+            ?.takeIf { it.hasKey("fontSize") }
+            ?.let { (it.getDouble("fontSize") * 2.5).dp }
+            ?: 40.dp
+
+        val maxWidthDp: androidx.compose.ui.unit.Dp? = maxWidthPx?.let {
+            // Will be converted inside the composable using LocalDensity
+            it.dp
+        }
+
+        view.setContent {
+            MaterialTheme {
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .background(Color.Transparent),
+                    propagateMinConstraints = false
+                ) {
+                    val density = LocalDensity.current.density
+                    val resolvedMaxWidthDp = maxWidthPx?.let { (it / density).dp }
+
+                    PdfRendererView(
+                        uri                   = uri,
+                        initialPageIndex      = pageIndex,
+                        maxWidthDp            = resolvedMaxWidthDp,
+                        maxZoom               = 2.5f,
+                        screenWidthPercentage = screenPct,
+                        iconUrls              = iconUrls,
+                        iconSize              = iconSizeDp,
+                        defaultZoom           = defaultZoom,
+                        isFullScreen          = isFullScreen,
+                        rightLayout           = rightLayout,
+                        backButtonText        = backButtonText,
+                        headerText            = headerText,
+                        onFullScreenChange    = { fs -> dispatchFullScreenEvent(view, fs) },
+                        onLeftScreenChange    = { ls -> dispatchLeftScreenEvent(view, ls) },
+                        onRightScreenChange   = { rs -> dispatchRightScreenEvent(view, rs) },
+                        onZoomChange          = { pct -> dispatchZoomEvent(view, pct) }
+                    )
+                }
+            }
+        }
+    }
+
+    // ── New-arch event dispatch ──────────────────────────────────────────────
+    // UIManagerHelper.getEventDispatcherForReactTag replaces the deprecated
+    // RCTEventEmitter pattern from the old bridge architecture.
+
+    private fun dispatchFullScreenEvent(view: ComposeView, isFullScreen: Boolean) {
+        val ctx = view.context as? ThemedReactContext ?: return
+        UIManagerHelper.getEventDispatcherForReactTag(ctx, view.id)
+            ?.dispatchEvent(
+                FullScreenChangeEvent(UIManagerHelper.getSurfaceId(view), view.id, isFullScreen)
+            )
+    }
+
+    private fun dispatchLeftScreenEvent(view: ComposeView, isLeftScreen: Boolean) {
+        val ctx = view.context as? ThemedReactContext ?: return
+        UIManagerHelper.getEventDispatcherForReactTag(ctx, view.id)
+            ?.dispatchEvent(
+                LeftScreenChangeEvent(UIManagerHelper.getSurfaceId(view), view.id, isLeftScreen)
+            )
+    }
+
+    private fun dispatchRightScreenEvent(view: ComposeView, isRightScreen: Boolean) {
+        val ctx = view.context as? ThemedReactContext ?: return
+        UIManagerHelper.getEventDispatcherForReactTag(ctx, view.id)
+            ?.dispatchEvent(
+                RightScreenChangeEvent(UIManagerHelper.getSurfaceId(view), view.id, isRightScreen)
+            )
+    }
+
+    private fun dispatchZoomEvent(view: ComposeView, zoomPercentage: Int) {
+        val ctx = view.context as? ThemedReactContext ?: return
+        UIManagerHelper.getEventDispatcherForReactTag(ctx, view.id)
+            ?.dispatchEvent(
+                ZoomChangeEvent(UIManagerHelper.getSurfaceId(view), view.id, zoomPercentage)
+            )
+    }
+
+    // ── Event registration map for React Native JS layer ────────────────────
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> = mapOf(
+        FullScreenChangeEvent.EVENT_NAME  to mapOf("registrationName" to "onFullScreenChange"),
+        ZoomChangeEvent.EVENT_NAME        to mapOf("registrationName" to "onZoomChange"),
+        LeftScreenChangeEvent.EVENT_NAME  to mapOf("registrationName" to "onLeftScreenChange"),
+        RightScreenChangeEvent.EVENT_NAME to mapOf("registrationName" to "onRightScreenChange")
+    )
+
+    companion object {
+        const val VIEW_NAME = "PdfViewerView"
+    }
+}
+
+private val Number.dp: androidx.compose.ui.unit.Dp
+    get() = androidx.compose.ui.unit.Dp(this.toFloat())

package/android/src/main/java/com/pdfrender/PdfViewerFragment.kt

@@ -0,0 +1,129 @@
+package com.pdfrender
+
+import android.net.Uri
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.compose.material.MaterialTheme
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+
+/**
+ * PdfViewerFragment
+ *
+ * Activity-independent PDF viewer. Drop it into any FragmentActivity —
+ * no PdfViewerActivity is spawned, no Intent required.
+ *
+ * Usage (from any FragmentActivity or from the TurboModule):
+ *   PdfViewerFragment.show(activity, "file:///path/to/file.pdf", pageIndex = 0)
+ *
+ * Dismiss:
+ *   PdfViewerFragment.dismiss(activity)
+ *   // or the user presses the system back button (addToBackStack handles it)
+ */
+class PdfViewerFragment : Fragment() {
+
+    // ── Public callback interface ────────────────────────────────────────────
+    interface Listener {
+        fun onPageChanged(pageIndex: Int, totalPages: Int) = Unit
+        fun onFullScreenChanged(isFullScreen: Boolean) = Unit
+        fun onZoomChanged(zoomPercentage: Int) = Unit
+        fun onDismiss() = Unit
+    }
+
+    var listener: Listener? = null
+
+    // ── Arguments ────────────────────────────────────────────────────────────
+    private val pdfUri: String get() = requireArguments().getString(ARG_URI)!!
+    private val initialPage: Int get() = requireArguments().getInt(ARG_PAGE, -1)
+    private val defaultZoom: Float get() = requireArguments().getFloat(ARG_ZOOM, 1.5f)
+    private val isFullScreen: Boolean get() = requireArguments().getBoolean(ARG_FULLSCREEN, false)
+
+    // ── Fragment lifecycle ───────────────────────────────────────────────────
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View = ComposeView(requireContext()).apply {
+        // Dispose Compose tree when the view lifecycle is destroyed.
+        // This covers Fragment being removed AND detached in a ViewPager.
+        setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+
+        setContent {
+            MaterialTheme {
+                PdfRendererView(
+                    uri = Uri.parse(pdfUri),
+                    initialPageIndex = initialPage,
+                    defaultZoom = defaultZoom,
+                    isFullScreen = isFullScreen,
+                    onFullScreenChange = { fs ->
+                        listener?.onFullScreenChanged(fs)
+                    },
+                    onZoomChange = { pct ->
+                        listener?.onZoomChanged(pct)
+                    }
+                )
+            }
+        }
+    }
+
+    // ── Companion (static factory) ───────────────────────────────────────────
+    companion object {
+        private const val TAG = "PdfViewerFragment"
+        private const val ARG_URI        = "pdf_uri"
+        private const val ARG_PAGE       = "initial_page"
+        private const val ARG_ZOOM       = "default_zoom"
+        private const val ARG_FULLSCREEN = "is_full_screen"
+
+        /**
+         * Show the PDF viewer overlaid on top of the host Activity's content.
+         * The fragment is added to the back-stack so the system back button
+         * dismisses it automatically.
+         *
+         * @param activity  Any FragmentActivity — your own app's Activity.
+         * @param uri       PDF URI (file:// or content://)
+         * @param pageIndex 0-based page to scroll to on open (-1 = first page)
+         * @param defaultZoom  Initial zoom level (1.0 = 100%, 1.5 = 150%)
+         * @param isFullScreen Start in full-screen mode
+         * @param listener  Optional callback for page/zoom/dismiss events
+         */
+        fun show(
+            activity: FragmentActivity,
+            uri: String,
+            pageIndex: Int = -1,
+            defaultZoom: Float = 1.5f,
+            isFullScreen: Boolean = false,
+            listener: Listener? = null
+        ): PdfViewerFragment {
+            val fragment = PdfViewerFragment().also { f ->
+                f.listener = listener
+                f.arguments = Bundle().apply {
+                    putString(ARG_URI, uri)
+                    putInt(ARG_PAGE, pageIndex)
+                    putFloat(ARG_ZOOM, defaultZoom)
+                    putBoolean(ARG_FULLSCREEN, isFullScreen)
+                }
+            }
+            activity.supportFragmentManager
+                .beginTransaction()
+                .add(android.R.id.content, fragment, TAG)
+                .addToBackStack(TAG)
+                .commit()
+            return fragment
+        }
+
+        /**
+         * Dismiss the currently visible viewer (if any).
+         */
+        fun dismiss(activity: FragmentActivity) {
+            val fm = activity.supportFragmentManager
+            val f = fm.findFragmentByTag(TAG) ?: return
+            fm.beginTransaction().remove(f).commit()
+            try { fm.popBackStack(TAG, androidx.fragment.app.FragmentManager.POP_BACK_STACK_INCLUSIVE) }
+            catch (_: Exception) {}
+        }
+    }
+}

package/android/src/main/java/com/pdfrender/PdfViewerTurboModule.kt

@@ -0,0 +1,158 @@
+package com.pdfrender
+
+import android.graphics.pdf.PdfDocument
+import android.os.Handler
+import android.os.Looper
+import android.util.Base64
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.io.FileOutputStream
+
+/**
+ * PdfViewerTurboModule — New Architecture TurboModule
+ *
+ * Replaces the old PdfModule (which extended ReactContextBaseJavaModule).
+ * Now extends NativePdfViewerModuleSpec — the codegen-generated abstract class
+ * that gives compile-time type safety between the JS spec and this implementation.
+ *
+ * Key changes vs old PdfModule:
+ *  1. openPdfInNativeViewer → openPdfViewer: shows PdfViewerFragment inside the
+ *     host Activity instead of starting a separate PdfViewerActivity.
+ *  2. All method signatures match NativePdfViewerModule.ts exactly.
+ *  3. @ReactModule annotation enables lazy TurboModule loading.
+ */
+@ReactModule(name = PdfViewerTurboModule.NAME)
+class PdfViewerTurboModule(reactContext: ReactApplicationContext) :
+    NativePdfViewerModuleSpec(reactContext) {
+
+    override fun getName(): String = NAME
+
+    // ── Open PDF in host Activity (Fragment-based, no new Activity) ──────────
+    override fun openPdfViewer(uri: String, pageIndex: Double, defaultZoom: Double) {
+        val activity = reactApplicationContext.currentActivity as? FragmentActivity
+            ?: run {
+                // Emit an error event the JS layer can subscribe to
+                reactApplicationContext.emitDeviceEvent(
+                    "PdfViewerError",
+                    Arguments.createMap().apply {
+                        putString("error", "Host Activity is not a FragmentActivity — cannot show PdfViewerFragment")
+                    }
+                )
+                return
+            }
+
+        Handler(Looper.getMainLooper()).post {
+            PdfViewerFragment.show(
+                activity    = activity,
+                uri         = uri,
+                pageIndex   = pageIndex.toInt(),
+                defaultZoom = defaultZoom.toFloat(),
+                listener    = object : PdfViewerFragment.Listener {
+                    override fun onFullScreenChanged(isFullScreen: Boolean) {
+                        reactApplicationContext.emitDeviceEvent(
+                            "PdfFullScreenChanged",
+                            Arguments.createMap().apply { putBoolean("isFullScreen", isFullScreen) }
+                        )
+                    }
+                    override fun onZoomChanged(zoomPercentage: Int) {
+                        reactApplicationContext.emitDeviceEvent(
+                            "PdfZoomChanged",
+                            Arguments.createMap().apply { putInt("zoomPercentage", zoomPercentage) }
+                        )
+                    }
+                    override fun onDismiss() {
+                        reactApplicationContext.emitDeviceEvent(
+                            "PdfViewerDismissed",
+                            Arguments.createMap()
+                        )
+                    }
+                }
+            )
+        }
+    }
+
+    // ── Dismiss the Fragment viewer ──────────────────────────────────────────
+    override fun dismissPdfViewer() {
+        val activity = reactApplicationContext.currentActivity as? FragmentActivity ?: return
+        Handler(Looper.getMainLooper()).post {
+            PdfViewerFragment.dismiss(activity)
+        }
+    }
+
+    // ── Get page count without rendering ────────────────────────────────────
+    override fun getPdfPageCount(uri: String, promise: Promise) {
+        Thread {
+            try {
+                val pfd = reactApplicationContext.contentResolver.openFileDescriptor(
+                    android.net.Uri.parse(uri), "r"
+                )
+                if (pfd == null) {
+                    promise.reject("PDF_ERROR", "Cannot open PDF file: $uri")
+                    return@Thread
+                }
+                val renderer = android.graphics.pdf.PdfRenderer(pfd)
+                val count = renderer.pageCount
+                renderer.close()
+                pfd.close()
+                promise.resolve(count)
+            } catch (e: Exception) {
+                promise.reject("PDF_PAGE_COUNT_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    // ── Create multi-page PDF as Base64 ─────────────────────────────────────
+    // Preserved from old PdfModule — logic unchanged.
+    override fun createMultiPagePdfBase64(
+        pages: ReadableArray,
+        widthPx: Double,
+        heightPx: Double,
+        promise: Promise
+    ) {
+        Thread {
+            try {
+                val pdfDocument = PdfDocument()
+
+                for (i in 0 until pages.size()) {
+                    val pageObj = pages.getMap(i) ?: continue
+                    val title   = pageObj.getString("title") ?: "Untitled"
+                    val body    = pageObj.getString("body")  ?: ""
+
+                    val bitmap = renderComposableToBitmap(
+                        context  = reactApplicationContext,
+                        widthPx  = widthPx.toInt(),
+                        heightPx = heightPx.toInt(),
+                        title    = title,
+                        body     = body
+                    )
+
+                    val pageInfo = PdfDocument.PageInfo.Builder(bitmap.width, bitmap.height, i + 1).create()
+                    val page = pdfDocument.startPage(pageInfo)
+                    page.canvas.drawBitmap(bitmap, 0f, 0f, null)
+                    pdfDocument.finishPage(page)
+                    bitmap.recycle()
+                }
+
+                val outFile = File(reactApplicationContext.cacheDir, "pdf_${System.currentTimeMillis()}.pdf")
+                FileOutputStream(outFile).use { fos ->
+                    pdfDocument.writeTo(fos)
+                }
+                pdfDocument.close()
+
+                val base64 = Base64.encodeToString(outFile.readBytes(), Base64.DEFAULT)
+                promise.resolve(Arguments.createMap().apply {
+                    putString("base64", base64)
+                    putString("path", outFile.absolutePath)
+                })
+            } catch (e: Exception) {
+                promise.reject("PDF_CREATE_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    companion object {
+        const val NAME = "NativePdfViewerModule"
+    }
+}

package/android/src/main/java/com/pdfrender/events/FullScreenChangeEvent.kt

@@ -0,0 +1,26 @@
+package com.pdfrender.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fabric event emitted when the PDF viewer enters or exits full-screen mode.
+ * Dispatched via UIManagerHelper.getEventDispatcherForReactTag() — the new-arch way.
+ */
+class FullScreenChangeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val isFullScreen: Boolean
+) : Event<FullScreenChangeEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = EVENT_NAME
+
+    override fun getEventData(): WritableMap = Arguments.createMap().apply {
+        putBoolean("isFullScreen", isFullScreen)
+    }
+
+    companion object {
+        const val EVENT_NAME = "topFullScreenChange"
+    }
+}

package/android/src/main/java/com/pdfrender/events/LeftScreenChangeEvent.kt

@@ -0,0 +1,22 @@
+package com.pdfrender.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class LeftScreenChangeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val isLeftScreen: Boolean
+) : Event<LeftScreenChangeEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = EVENT_NAME
+
+    override fun getEventData(): WritableMap = Arguments.createMap().apply {
+        putBoolean("isLeftScreen", isLeftScreen)
+    }
+
+    companion object {
+        const val EVENT_NAME = "topLeftScreenChange"
+    }
+}

package/android/src/main/java/com/pdfrender/events/RightScreenChangeEvent.kt

@@ -0,0 +1,22 @@
+package com.pdfrender.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class RightScreenChangeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val isRightScreen: Boolean
+) : Event<RightScreenChangeEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = EVENT_NAME
+
+    override fun getEventData(): WritableMap = Arguments.createMap().apply {
+        putBoolean("isRightScreen", isRightScreen)
+    }
+
+    companion object {
+        const val EVENT_NAME = "topRightScreenChange"
+    }
+}

package/android/src/main/java/com/pdfrender/events/ZoomChangeEvent.kt

@@ -0,0 +1,22 @@
+package com.pdfrender.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class ZoomChangeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val zoomPercentage: Int
+) : Event<ZoomChangeEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = EVENT_NAME
+
+    override fun getEventData(): WritableMap = Arguments.createMap().apply {
+        putInt("zoomPercentage", zoomPercentage)
+    }
+
+    companion object {
+        const val EVENT_NAME = "topZoomChange"
+    }
+}

package/ios/PdfCacheManager.swift

@@ -0,0 +1,44 @@
+import UIKit
+
+/// Thread-safe LRU page-image cache backed by NSCache.
+///
+/// NSCache is already thread-safe and evicts entries automatically under
+/// memory pressure — no manual locking is required.
+final class PdfCacheManager {
+
+    static let shared = PdfCacheManager()
+
+    private let cache = NSCache<NSString, UIImage>()
+
+    private init() {
+        cache.countLimit     = PdfConstants.cacheCountLimit
+        cache.totalCostLimit = PdfConstants.cacheTotalCostLimit
+    }
+
+    // MARK: - Access
+
+    func image(forKey key: String) -> UIImage? {
+        cache.object(forKey: key as NSString)
+    }
+
+    /// Cost is approximated as width × height × 4 bytes (RGBA).
+    func setImage(_ image: UIImage, forKey key: String) {
+        let cost = Int(image.size.width * image.size.height * 4)
+        cache.setObject(image, forKey: key as NSString, cost: cost)
+    }
+
+    func remove(forKey key: String) {
+        cache.removeObject(forKey: key as NSString)
+    }
+
+    func removeAll() {
+        cache.removeAllObjects()
+    }
+
+    // MARK: - Cache key helpers
+
+    /// Stable cache key: "<pageIndex>_<Int(targetWidth)>"
+    static func key(pageIndex: Int, targetWidth: CGFloat) -> String {
+        "page_\(pageIndex)_\(Int(targetWidth))"
+    }
+}