@thatkid02/react-native-pdf-viewer 0.0.1

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","callback","PdfViewerConfig","require","PdfViewerView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,EAAEC,QAAQ,QAAQ,4BAA4B;AAEvE,MAAMC,eAAe,GAAGC,OAAO,CAAC,wDAAwD,CAAC;AAGzF,OAAO,MAAMC,aAAa,GAAGJ,gBAAgB,CAC3C,WAAW,EACX,MAAME,eACR,CAAC;;AAED;;AAGA;;AAYA;AACA,SAASD,QAAQ","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/PdfViewer.nitro.d.ts

@@ -0,0 +1,67 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export interface LoadCompleteEvent {
+    pageCount: number;
+    pageWidth: number;
+    pageHeight: number;
+}
+export interface PageChangeEvent {
+    page: number;
+    pageCount: number;
+}
+export interface ScaleChangeEvent {
+    scale: number;
+}
+export interface ErrorEvent {
+    message: string;
+    code: string;
+}
+export interface ThumbnailGeneratedEvent {
+    page: number;
+    uri: string;
+}
+export interface LoadingChangeEvent {
+    isLoading: boolean;
+}
+export interface IOSPdfViewerProps {
+    horizontal?: boolean;
+    enablePaging?: boolean;
+}
+export interface PdfViewerProps extends HybridViewProps {
+    /**
+     * PDF source URI
+     * @supported file://, http://, https://
+     * @security For production apps, prefer https:// URLs to ensure secure content delivery
+     * @example "https://example.com/document.pdf"
+     * @example "file:///path/to/local/document.pdf"
+     */
+    source?: string;
+    /**
+     * Horizontal scroll direction (iOS only)
+     * @platform ios
+     */
+    horizontal?: boolean;
+    /**
+     * Enable paging mode (iOS only)
+     * @platform ios
+     */
+    enablePaging?: boolean;
+    spacing?: number;
+    enableZoom?: boolean;
+    minScale?: number;
+    maxScale?: number;
+    showsActivityIndicator?: boolean;
+    onLoadComplete?: (event: LoadCompleteEvent) => void;
+    onPageChange?: (event: PageChangeEvent) => void;
+    onScaleChange?: (event: ScaleChangeEvent) => void;
+    onError?: (event: ErrorEvent) => void;
+    onThumbnailGenerated?: (event: ThumbnailGeneratedEvent) => void;
+    onLoadingChange?: (event: LoadingChangeEvent) => void;
+}
+export interface PdfViewerMethods extends HybridViewMethods {
+    goToPage(page: number): void;
+    setScale(scale: number): void;
+    generateThumbnail(page: number): void;
+    generateAllThumbnails(): void;
+}
+export type PdfViewer = HybridView<PdfViewerProps, PdfViewerMethods>;
+//# sourceMappingURL=PdfViewer.nitro.d.ts.map

package/lib/typescript/src/PdfViewer.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PdfViewer.nitro.d.ts","sourceRoot":"","sources":["../../../src/PdfViewer.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;CACpB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IAGjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAGjC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAChD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAG7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtC,qBAAqB,IAAI,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,8 @@
+import { callback } from 'react-native-nitro-modules';
+import type { HybridRef } from 'react-native-nitro-modules';
+import type { PdfViewerMethods, PdfViewerProps } from './PdfViewer.nitro';
+export declare const PdfViewerView: import("react-native-nitro-modules").ReactNativeView<PdfViewerProps, PdfViewerMethods>;
+export type PdfViewerRef = HybridRef<PdfViewerProps, PdfViewerMethods>;
+export type { LoadCompleteEvent, PageChangeEvent, ScaleChangeEvent, ErrorEvent, ThumbnailGeneratedEvent, LoadingChangeEvent, PdfViewerProps, PdfViewerMethods, } from './PdfViewer.nitro';
+export { callback };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE1E,eAAO,MAAM,aAAa,wFAGzB,CAAC;AAGF,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;AAGvE,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["pdfviewer"],
+  "ios": {
+    "iosModuleName": "PdfViewer"
+  },
+  "android": {
+    "androidNamespace": ["pdfviewer"],
+    "androidCxxLibName": "pdfviewer"
+  },
+  "autolinking": {
+    "PdfViewer": {
+      "swift": "HybridPdfViewer",
+      "kotlin": "HybridPdfViewer"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JErrorEvent.hpp

@@ -0,0 +1,57 @@
+///
+/// JErrorEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ErrorEvent.hpp"
+
+#include <string>
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ErrorEvent" and the the Kotlin data class "ErrorEvent".
+   */
+  struct JErrorEvent final: public jni::JavaClass<JErrorEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/ErrorEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ErrorEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ErrorEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      static const auto fieldCode = clazz->getField<jni::JString>("code");
+      jni::local_ref<jni::JString> code = this->getFieldValue(fieldCode);
+      return ErrorEvent(
+        message->toStdString(),
+        code->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JErrorEvent::javaobject> fromCpp(const ErrorEvent& value) {
+      return newInstance(
+        jni::make_jstring(value.message),
+        jni::make_jstring(value.code)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_ErrorEvent.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_ErrorEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ErrorEvent.hpp"
+#include <functional>
+#include "JErrorEvent.hpp"
+#include <string>
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: ErrorEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ErrorEvent: public jni::JavaClass<JFunc_void_ErrorEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ErrorEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ErrorEvent` instance holds through JNI.
+     */
+    void invoke(const ErrorEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JErrorEvent> /* event */)>("invoke");
+      method(self(), JErrorEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ErrorEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_ErrorEvent_cxx final: public jni::HybridClass<JFunc_void_ErrorEvent_cxx, JFunc_void_ErrorEvent> {
+  public:
+    static jni::local_ref<JFunc_void_ErrorEvent::javaobject> fromCpp(const std::function<void(const ErrorEvent& /* event */)>& func) {
+      return JFunc_void_ErrorEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ErrorEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JErrorEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const ErrorEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ErrorEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ErrorEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ErrorEvent_cxx(const std::function<void(const ErrorEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const ErrorEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_LoadCompleteEvent.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_LoadCompleteEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "LoadCompleteEvent.hpp"
+#include <functional>
+#include "JLoadCompleteEvent.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: LoadCompleteEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_LoadCompleteEvent: public jni::JavaClass<JFunc_void_LoadCompleteEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_LoadCompleteEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_LoadCompleteEvent` instance holds through JNI.
+     */
+    void invoke(const LoadCompleteEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLoadCompleteEvent> /* event */)>("invoke");
+      method(self(), JLoadCompleteEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_LoadCompleteEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_LoadCompleteEvent_cxx final: public jni::HybridClass<JFunc_void_LoadCompleteEvent_cxx, JFunc_void_LoadCompleteEvent> {
+  public:
+    static jni::local_ref<JFunc_void_LoadCompleteEvent::javaobject> fromCpp(const std::function<void(const LoadCompleteEvent& /* event */)>& func) {
+      return JFunc_void_LoadCompleteEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_LoadCompleteEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JLoadCompleteEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const LoadCompleteEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_LoadCompleteEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_LoadCompleteEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_LoadCompleteEvent_cxx(const std::function<void(const LoadCompleteEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const LoadCompleteEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_LoadingChangeEvent.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_LoadingChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "LoadingChangeEvent.hpp"
+#include <functional>
+#include "JLoadingChangeEvent.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: LoadingChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_LoadingChangeEvent: public jni::JavaClass<JFunc_void_LoadingChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_LoadingChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_LoadingChangeEvent` instance holds through JNI.
+     */
+    void invoke(const LoadingChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLoadingChangeEvent> /* event */)>("invoke");
+      method(self(), JLoadingChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_LoadingChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_LoadingChangeEvent_cxx final: public jni::HybridClass<JFunc_void_LoadingChangeEvent_cxx, JFunc_void_LoadingChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_LoadingChangeEvent::javaobject> fromCpp(const std::function<void(const LoadingChangeEvent& /* event */)>& func) {
+      return JFunc_void_LoadingChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_LoadingChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JLoadingChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const LoadingChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_LoadingChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_LoadingChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_LoadingChangeEvent_cxx(const std::function<void(const LoadingChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const LoadingChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_PageChangeEvent.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_PageChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "PageChangeEvent.hpp"
+#include <functional>
+#include "JPageChangeEvent.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: PageChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PageChangeEvent: public jni::JavaClass<JFunc_void_PageChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_PageChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PageChangeEvent` instance holds through JNI.
+     */
+    void invoke(const PageChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPageChangeEvent> /* event */)>("invoke");
+      method(self(), JPageChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PageChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_PageChangeEvent_cxx final: public jni::HybridClass<JFunc_void_PageChangeEvent_cxx, JFunc_void_PageChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PageChangeEvent::javaobject> fromCpp(const std::function<void(const PageChangeEvent& /* event */)>& func) {
+      return JFunc_void_PageChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PageChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPageChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PageChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_PageChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PageChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PageChangeEvent_cxx(const std::function<void(const PageChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PageChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_ScaleChangeEvent.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_ScaleChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ScaleChangeEvent.hpp"
+#include <functional>
+#include "JScaleChangeEvent.hpp"
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: ScaleChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ScaleChangeEvent: public jni::JavaClass<JFunc_void_ScaleChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ScaleChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ScaleChangeEvent` instance holds through JNI.
+     */
+    void invoke(const ScaleChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScaleChangeEvent> /* event */)>("invoke");
+      method(self(), JScaleChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ScaleChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_ScaleChangeEvent_cxx final: public jni::HybridClass<JFunc_void_ScaleChangeEvent_cxx, JFunc_void_ScaleChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_ScaleChangeEvent::javaobject> fromCpp(const std::function<void(const ScaleChangeEvent& /* event */)>& func) {
+      return JFunc_void_ScaleChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ScaleChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JScaleChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const ScaleChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ScaleChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ScaleChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ScaleChangeEvent_cxx(const std::function<void(const ScaleChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const ScaleChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer

package/nitrogen/generated/android/c++/JFunc_void_ThumbnailGeneratedEvent.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_ThumbnailGeneratedEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ThumbnailGeneratedEvent.hpp"
+#include <functional>
+#include "JThumbnailGeneratedEvent.hpp"
+#include <string>
+
+namespace margelo::nitro::pdfviewer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: ThumbnailGeneratedEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ThumbnailGeneratedEvent: public jni::JavaClass<JFunc_void_ThumbnailGeneratedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ThumbnailGeneratedEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ThumbnailGeneratedEvent` instance holds through JNI.
+     */
+    void invoke(const ThumbnailGeneratedEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JThumbnailGeneratedEvent> /* event */)>("invoke");
+      method(self(), JThumbnailGeneratedEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ThumbnailGeneratedEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_ThumbnailGeneratedEvent_cxx final: public jni::HybridClass<JFunc_void_ThumbnailGeneratedEvent_cxx, JFunc_void_ThumbnailGeneratedEvent> {
+  public:
+    static jni::local_ref<JFunc_void_ThumbnailGeneratedEvent::javaobject> fromCpp(const std::function<void(const ThumbnailGeneratedEvent& /* event */)>& func) {
+      return JFunc_void_ThumbnailGeneratedEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ThumbnailGeneratedEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JThumbnailGeneratedEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const ThumbnailGeneratedEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pdfviewer/Func_void_ThumbnailGeneratedEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ThumbnailGeneratedEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ThumbnailGeneratedEvent_cxx(const std::function<void(const ThumbnailGeneratedEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const ThumbnailGeneratedEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::pdfviewer