@rejaul/react-native-printer-kit 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Rejaul Karim
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+# react-native-printer-kit
+
+A professional-grade React Native module for printing directly to Bluetooth POS/thermal (ESC/POS) printers on **Android devices only** — no third-party printer app, no OS print dialog. Print raw text, images, PDFs, and full HTML/CSS content, including **Bangla and other non-Latin scripts** that ESC/POS printer fonts don't support natively.
+
+> **Important:** This library is **exclusively for Android**. Bluetooth Classic SPP + ESC/POS is an Android-specific integration; iOS does not expose the APIs this relies on.
+
+[![npm version](https://img.shields.io/npm/v/@rejaul/react-native-printer-kit.svg)](https://www.npmjs.com/package/@rejaul/react-native-printer-kit)
+[![license](https://img.shields.io/npm/l/@rejaul/react-native-printer-kit.svg)](LICENSE)
+[![Platform - Android Only](https://img.shields.io/badge/Platform-Android%20Only-green)]()
+[![Kotlin](https://img.shields.io/badge/Language-Kotlin-purple)]()
+[![TypeScript](https://img.shields.io/badge/TypeScript-Supported-blue)]()
+
+## Why this exists
+
+Most ESC/POS printer libraries only send raw text or a single pre-made image. They can't render real content — an actual HTML/CSS receipt layout, a PDF, or text in a script the printer's built-in font doesn't have (Bangla, Arabic, Hindi, etc.). This library renders your HTML/PDF to a bitmap on-device (Android's own `WebView` and `PdfRenderer` — no external rendering library) and sends it to the printer as a dithered ESC/POS raster image.
+
+It's a thin React Native bridge over [`android-printer-kit`](https://github.com/DeveloperRejaul/android-printer-kit), the native Kotlin library that does the actual work.
+
+## Features
+
+- **Direct Bluetooth Classic (SPP) connection** to any paired ESC/POS printer.
+- **HTML → PDF → print** pipeline, so you can print an actual styled receipt/report.
+- **PDF → image → print** pipeline via Android's built-in `PdfRenderer`.
+- **Non-Latin text support** (Bangla and others) via image-based rendering.
+- **Persistent connection**: the printer stays connected even if the app is swiped away from Recents (a foreground service keeps it alive).
+- **Auto-reconnect**: remembers the last connected printer and reconnects automatically next time the app starts.
+- **Banded raster printing**: images are sent in small, paced chunks, since many cheap ESC/POS boards silently drop large single print commands.
+- **Type-safe**: full TypeScript definitions, backed by a New Architecture TurboModule.
+
+## Platform Support
+
+| Platform | Status | Details |
+|----------|--------|---------|
+| **Android** | **Fully Supported** | API Level 24+ required |
+| **iOS** | **Not Supported** | No Bluetooth Classic SPP / ESC/POS API equivalent |
+
+## Scope
+
+This library speaks **Bluetooth Classic SPP + ESC/POS** — the standard used by virtually all budget Bluetooth receipt/thermal printers. It does not support Bluetooth LE printers, WiFi/network printers, USB-connected printers, or non-ESC/POS protocols (PCL/PostScript inkjet & laser printers).
+
+## Minimum Requirements
+
+- **React Native** >= 0.76 (New Architecture / TurboModules)
+- **Android API Level** >= 24 (Android 7.0+)
+- **Kotlin** 2.0.21+ (included in the build system)
+
+## Installation
+
+```bash
+npm install @rejaul/react-native-printer-kit
+# or
+yarn add @rejaul/react-native-printer-kit
+```
+
+Nothing to configure manually — all required Bluetooth and foreground-service permissions are declared by the underlying native library's manifest and merge in automatically. You still need to request the runtime `BLUETOOTH_CONNECT` (Android 12+) and `POST_NOTIFICATIONS` (Android 13+) permissions at runtime — `requestBluetoothPermission()` handles both in one call; see [Permissions](#permissions) below.
+
+## Quick Start
+
+```typescript
+import {
+  hasBluetoothPermission,
+  requestBluetoothPermission,
+  getBondedBluetoothPrinters,
+  connectPrinter,
+  printText,
+  printHtml,
+} from '@rejaul/react-native-printer-kit';
+
+async function printReceipt() {
+  // 1. Make sure Bluetooth permission is granted (Android 12+)
+  if (!hasBluetoothPermission()) {
+    const granted = await requestBluetoothPermission();
+    if (!granted) return;
+  }
+
+  // 2. List paired printers and connect to one
+  const printers = getBondedBluetoothPrinters();
+  if (printers.length === 0) return;
+  await connectPrinter(printers[0]!.address);
+
+  // 3a. Print plain text
+  await printText('Hello from PrinterKit');
+
+  // 3b. Or print a full HTML receipt (Bangla, styling, everything)
+  const ok = await printHtml(myReceiptHtml);
+  console.log('Printed:', ok);
+}
+```
+
+## Permissions
+
+```typescript
+import {
+  hasBluetoothPermission,
+  requestBluetoothPermission,
+} from '@rejaul/react-native-printer-kit';
+
+// Synchronous check - always true below Android 12
+const granted = hasBluetoothPermission();
+
+// Shows the system permission dialog if needed (no-op if already granted,
+// or not required on this Android version)
+const result = await requestBluetoothPermission();
+```
+
+## API Reference
+
+### Permissions
+
+#### `hasBluetoothPermission(): boolean`
+Whether `BLUETOOTH_CONNECT` specifically is already granted (always `true` below Android 12) — the permission that actually gates connect/print.
+
+#### `requestBluetoothPermission(): Promise<boolean>`
+Shows the system permission dialog(s) for whatever's needed on this Android version — `BLUETOOTH_CONNECT` (12+) and `POST_NOTIFICATIONS` (13+, for the persistent-connection notification's visibility) — and resolves based on `BLUETOOTH_CONNECT`'s result specifically. A denied `POST_NOTIFICATIONS` alone doesn't make this resolve `false`: printing still works, the notification just won't show.
+
+### Connection
+
+#### `getBondedBluetoothPrinters(): BluetoothPrinterDevice[]`
+Lists Bluetooth devices already paired with the phone via Android's own Bluetooth settings.
+
+#### `connectPrinter(address: string): Promise<boolean>`
+Opens an RFCOMM/SPP connection to the paired printer. Closes any existing connection first, and remembers the address for auto-reconnect on the next app launch.
+
+#### `disconnectPrinter(): Promise<void>`
+Closes the current connection and forgets it for auto-reconnect.
+
+#### `isConnectedPrinter(): Promise<boolean>`
+Whether a printer connection is currently open.
+
+#### `getConnectedPrinter(): Promise<BluetoothPrinterDevice | null>`
+The currently connected printer, if any.
+
+### Printing
+
+#### `printText(text: string, feedLines?: number): Promise<void>`
+Prints raw text using the printer's built-in font. **ASCII only** — use `printHtml()` for Bangla or other non-Latin scripts.
+
+#### `printImage(imagePath: string, printerWidthDots?: number, feedLines?: number): Promise<void>`
+Prints an image file as a dithered ESC/POS raster image. `printerWidthDots`: 384 for 58mm printers, 576 for 80mm printers (default 384).
+
+#### `printImageBase64(base64: string, printerWidthDots?: number, feedLines?: number): Promise<void>`
+Same as above, from a base64-encoded image string.
+
+#### `pdfToImage(pdfPath: string, imageType?: 'PNG' | 'JPEG', page?: number, targetWidthPx?: number): Promise<string>`
+Renders one PDF page to an image file and returns its path.
+
+#### `printPdf(pdfPath: string, printerWidthDots?: number, page?: number, feedLines?: number): Promise<void>`
+`pdfToImage` + print, in one call.
+
+#### `htmlToPdf(html: string, pageWidthDp?: number, heightDp?: number, minPageHeightDp?: number): Promise<string | null>`
+Renders HTML to a PDF file using an off-screen `WebView` and returns its path, or `null` on failure. `pageWidthDp` controls how large the content renders (like a CSS viewport width), independent of the final printed width. Leave `heightDp` unset to auto-measure the real content height (recommended).
+
+#### `printHtml(html: string, printerWidthDots?: number, pageWidthDp?: number, heightDp?: number, minPageHeightDp?: number): Promise<boolean>`
+Full pipeline: `htmlToPdf` → `printPdf`. This is how you print Bangla (or other non-Latin) text or any real HTML/CSS layout.
+
+## Type Definitions
+
+```typescript
+type BluetoothPrinterDevice = {
+  name: string | null;
+  address: string;
+};
+
+type PrinterImageType = 'PNG' | 'JPEG';
+```
+
+## Persistent connection & auto-reconnect
+
+Connecting through this library keeps the printer connected even if the app is swiped away from Recents — the native side runs a foreground service that outlives the Activity/JS runtime. Every successful `connectPrinter()` call also remembers the device, so the next time the app is opened (even after being fully killed) it reconnects automatically without the user having to pick the printer again.
+
+## Printing Bangla / other non-Latin text
+
+ESC/POS printer firmware fonts only cover ASCII, so `printText()` can't render Bangla. For anything with non-Latin text, render it as an image instead — build a bitmap yourself and use `printImage()`/`printImageBase64()`, or write it as HTML/CSS and call `printHtml()`, which renders it with a real font via `WebView` and prints the result as a dithered raster image.
+
+## Example Application
+
+See the [`example`](./example) directory for a complete React Native application demonstrating permission handling, printer pairing/connection, and every print function above.
+
+```bash
+cd example
+yarn install
+yarn android
+```
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Code of Conduct
+
+This project adheres to the [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+MIT - See [LICENSE](LICENSE) file for details.
+
+## Support
+
+For issues, questions, or suggestions, please open an [issue on GitHub](https://github.com/DeveloperRejaul/react-native-printer-kit/issues).

package/ReactNativePrinterKit.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativePrinterKit"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/DeveloperRejaul/react-native-printer-kit.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,65 @@
+buildscript {
+  ext.ReactNativePrinterKit = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return ReactNativePrinterKit[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+    maven { url = uri("https://jitpack.io") }
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+
+if (project.extensions.findByName("kotlin") == null) {
+  apply plugin: "kotlin-android"
+}
+
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.rejaul.reactnativeprinterkit"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+  // JitPack resolves this multi-module repo by its GitHub repo name
+  // (android-printer-kit), not the internal Gradle module name (printerkit).
+  maven { url = uri("https://jitpack.io") }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation("com.github.DeveloperRejaul:android-printer-kit:v0.0.3")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/rejaul/reactnativeprinterkit/ReactNativePrinterKitModule.kt

@@ -0,0 +1,283 @@
+package com.rejaul.reactnativeprinterkit
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.PackageManager
+import android.os.IBinder
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.rezaul.printerkit.BluetoothPermissions
+import com.rezaul.printerkit.BluetoothPrinter
+import com.rezaul.printerkit.BluetoothPrinterDevice
+import com.rezaul.printerkit.BluetoothPrinterService
+import com.rezaul.printerkit.PrinterImageType
+import java.util.concurrent.Executors
+
+/**
+ * Bridges [com.rezaul.printerkit.BluetoothPrinter] to React Native.
+ *
+ * Connect/print calls run through a bound [BluetoothPrinterService] (started once,
+ * on module init) instead of a bare [BluetoothPrinter], so the connection survives
+ * the app being swiped away from Recents - see [BluetoothPrinterService]. Calls made
+ * before the service finishes binding (essentially instant, but not synchronous) are
+ * queued and run once it connects.
+ *
+ * All blocking Bluetooth/PDF/image I/O runs on a single background executor, off the
+ * calling (JS) thread - also serializing printer writes, since concurrent writes to
+ * the same socket from two overlapping calls would corrupt the output.
+ */
+class ReactNativePrinterKitModule(reactContext: ReactApplicationContext) :
+  NativeReactNativePrinterKitSpec(reactContext) {
+
+  private val executor = Executors.newSingleThreadExecutor()
+
+  // getBondedBluetoothPrinters() is synchronous (no connection involved) and must
+  // answer immediately, so it uses its own plain BluetoothPrinter rather than
+  // waiting on the service to bind.
+  private val standalonePrinter by lazy { BluetoothPrinter(reactApplicationContext) }
+
+  private var printerService: BluetoothPrinterService? = null
+  private val pendingActions = mutableListOf<(BluetoothPrinterService) -> Unit>()
+
+  private val serviceConnection = object : ServiceConnection {
+    override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
+      val service = (binder as BluetoothPrinterService.LocalBinder).getService()
+      printerService = service
+      val queued = synchronized(pendingActions) {
+        val copy = pendingActions.toList()
+        pendingActions.clear()
+        copy
+      }
+      queued.forEach { it(service) }
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+      printerService = null
+    }
+  }
+
+  init {
+    val intent = Intent(reactApplicationContext, BluetoothPrinterService::class.java)
+    reactApplicationContext.startService(intent)
+    reactApplicationContext.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
+  }
+
+  /** Runs [action] with the bound service, once available (queued if not yet bound). */
+  private fun withService(action: (BluetoothPrinterService) -> Unit) {
+    val service = printerService
+    if (service != null) {
+      action(service)
+    } else {
+      synchronized(pendingActions) { pendingActions.add(action) }
+    }
+  }
+
+  private fun deviceToMap(device: BluetoothPrinterDevice): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("name", device.name)
+    map.putString("address", device.address)
+    return map
+  }
+
+  override fun hasBluetoothPermission(): Boolean {
+    return BluetoothPermissions.isGranted(reactApplicationContext)
+  }
+
+  override fun requestBluetoothPermission(promise: Promise) {
+    // getRequiredPermissions() can list more than one permission (BLUETOOTH_CONNECT
+    // and, on Android 13+, POST_NOTIFICATIONS for the foreground service's ongoing
+    // notification) - request every one of them, not just check isGranted(), which
+    // only reflects BLUETOOTH_CONNECT and would otherwise skip requesting the rest.
+    val required = BluetoothPermissions.getRequiredPermissions()
+    val alreadyGranted = required.all {
+      ContextCompat.checkSelfPermission(reactApplicationContext, it) == PackageManager.PERMISSION_GRANTED
+    }
+    if (required.isEmpty() || alreadyGranted) {
+      promise.resolve(true)
+      return
+    }
+    val activity = currentActivity as? PermissionAwareActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "No current activity to request permission from")
+      return
+    }
+    activity.requestPermissions(required, PERMISSION_REQUEST_CODE) { requestCode, permissions, grantResults ->
+      if (requestCode == PERMISSION_REQUEST_CODE) {
+        promise.resolve(BluetoothPermissions.isGrantResult(requestCode, permissions, grantResults, PERMISSION_REQUEST_CODE))
+        true
+      } else {
+        false
+      }
+    }
+  }
+
+  override fun getBondedBluetoothPrinters(): WritableArray {
+    val result: WritableArray = Arguments.createArray()
+    standalonePrinter.getBondedBluetoothPrinters().forEach { device ->
+      result.pushMap(deviceToMap(device))
+    }
+    return result
+  }
+
+  override fun connectPrinter(address: String, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          promise.resolve(service.connectAndKeepAlive(address))
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun disconnectPrinter(promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          service.disconnect()
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun isConnectedPrinter(promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          promise.resolve(service.printer.isConnectedPrinter())
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun getConnectedPrinter(promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          val device = service.printer.getConnectedPrinter()
+          promise.resolve(device?.let { deviceToMap(it) })
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun printText(text: String, feedLines: Double?, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          service.printer.printText(text, (feedLines ?: 3.0).toInt())
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun printImage(imagePath: String, printerWidthDots: Double?, feedLines: Double?, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          service.printer.printImageFile(imagePath, (printerWidthDots ?: 384.0).toInt(), (feedLines ?: 3.0).toInt())
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun printImageBase64(base64: String, printerWidthDots: Double?, feedLines: Double?, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          service.printer.printImageBase64(base64, (printerWidthDots ?: 384.0).toInt(), (feedLines ?: 3.0).toInt())
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun pdfToImage(pdfPath: String, imageType: String?, page: Double?, targetWidthPx: Double?, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          val type = if (imageType == "JPEG") PrinterImageType.JPEG else PrinterImageType.PNG
+          val path = service.printer.pdfToImage(pdfPath, type, (page ?: 0.0).toInt(), targetWidthPx?.toInt())
+          promise.resolve(path)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun printPdf(pdfPath: String, printerWidthDots: Double?, page: Double?, feedLines: Double?, promise: Promise) {
+    withService { service ->
+      executor.execute {
+        try {
+          service.printer.printPdf(pdfPath, (printerWidthDots ?: 384.0).toInt(), (page ?: 0.0).toInt(), (feedLines ?: 3.0).toInt())
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("ERROR", e.message)
+        }
+      }
+    }
+  }
+
+  override fun htmlToPdf(html: String, pageWidthDp: Double?, heightDp: Double?, minPageHeightDp: Double?, promise: Promise) {
+    withService { service ->
+      service.printer.htmlToPdf(
+        html = html,
+        pageWidthDp = (pageWidthDp ?: 412.0).toInt(),
+        heightDp = heightDp?.toInt(),
+        minPageHeightDp = (minPageHeightDp ?: 1000.0).toInt()
+      ) { path ->
+        promise.resolve(path)
+      }
+    }
+  }
+
+  override fun printHtml(
+    html: String,
+    printerWidthDots: Double?,
+    pageWidthDp: Double?,
+    heightDp: Double?,
+    minPageHeightDp: Double?,
+    promise: Promise
+  ) {
+    withService { service ->
+      service.printer.printHtml(
+        html = html,
+        printerWidthDots = (printerWidthDots ?: 384.0).toInt(),
+        pageWidthDp = (pageWidthDp ?: 412.0).toInt(),
+        heightDp = heightDp?.toInt(),
+        minPageHeightDp = (minPageHeightDp ?: 1000.0).toInt()
+      ) { ok ->
+        promise.resolve(ok)
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = NativeReactNativePrinterKitSpec.NAME
+    private const val PERMISSION_REQUEST_CODE = 4201
+  }
+}

package/android/src/main/java/com/rejaul/reactnativeprinterkit/ReactNativePrinterKitPackage.kt

@@ -0,0 +1,31 @@
+package com.rejaul.reactnativeprinterkit
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class ReactNativePrinterKitPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == ReactNativePrinterKitModule.NAME) {
+      ReactNativePrinterKitModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      ReactNativePrinterKitModule.NAME to ReactModuleInfo(
+        name = ReactNativePrinterKitModule.NAME,
+        className = ReactNativePrinterKitModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}

package/ios/ReactNativePrinterKit.h

@@ -0,0 +1,5 @@
+#import <ReactNativePrinterKitSpec/ReactNativePrinterKitSpec.h>
+
+@interface ReactNativePrinterKit : NSObject <NativeReactNativePrinterKitSpec>
+
+@end

package/ios/ReactNativePrinterKit.mm

@@ -0,0 +1,21 @@
+#import "ReactNativePrinterKit.h"
+
+@implementation ReactNativePrinterKit
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(a * b);
+
+    return result;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeReactNativePrinterKitSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"ReactNativePrinterKit";
+}
+
+@end

package/lib/module/NativeReactNativePrinterKit.js

@@ -0,0 +1,8 @@
+"use strict";
+
+import { TurboModuleRegistry, Platform } from 'react-native';
+function getModule() {
+  return Platform.OS === 'android' ? TurboModuleRegistry.getEnforcing('ReactNativePrinterKit') : {};
+}
+export default getModule();
+//# sourceMappingURL=NativeReactNativePrinterKit.js.map

package/lib/module/NativeReactNativePrinterKit.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","Platform","getModule","OS","getEnforcing"],"sourceRoot":"../../src","sources":["NativeReactNativePrinterKit.ts"],"mappings":";;AAAA,SAASA,mBAAmB,EAAoBC,QAAQ,QAAQ,cAAc;AAgI9E,SAASC,SAASA,CAAA,EAAS;EACzB,OAAOD,QAAQ,CAACE,EAAE,KAAK,SAAS,GAC5BH,mBAAmB,CAACI,YAAY,CAAO,uBAAuB,CAAC,GAC9D,CAAC,CAAU;AAClB;AAEA,eAAeF,SAAS,CAAC,CAAC","ignoreList":[]}