@angadie/chittie-react-native 0.1.0

package/ChittieReactNative.podspec

@@ -0,0 +1,32 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ChittieReactNative"
+  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/octalpixel/chittie.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking / registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # C++ objects (if any)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  # nitrogen-generated autolinking (produced by `nitro-codegen`).
+  load 'nitrogen/generated/ios/ChittieReactNative+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Asyncdot Engineering
+
+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.
+
+Portions of this software are vendored from MIT-licensed projects and retain
+their original copyright notices; see VENDOR.md.
+
+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,80 @@
+# @angadie/chittie-react-native
+
+The **React Native backend for chittie** — a [Nitro](https://nitro.margelo.com) module that
+rasterizes **non-Latin text** (Sinhala/Tamil/Arabic) natively (**CoreText** on iOS,
+**android.graphics** on Android) and exposes it as chittie's `TextRasterizer`. No Skia.
+
+> **Dev client / bare RN only** — it's a native module, so it can't run in Expo Go. (Your printer
+> transport — BLE/USB — needs a dev client anyway, so this costs you nothing extra.) See the RFC:
+> `docs/rfc/rn-native.md`.
+
+## Install
+
+```sh
+npm i @angadie/chittie-react-native @angadie/chittie react-native-nitro-modules
+cd ios && pod install     # iOS
+# Android autolinks; rebuild the dev client.
+```
+
+The Nitro bindings (`nitrogen/`) are **generated and shipped** — you only re-run `npm run codegen`
+if you change the `.nitro.ts` spec. Built with **react-native-builder-bob** (`lib/commonjs|module|
+typescript`). Requires React Native's **new architecture**.
+
+## Use
+
+Pass the native rasterizer to `render()` — everything else is the same chittie API:
+
+```tsx
+import { render, Printer, Text, Row } from '@angadie/chittie';
+import { createNativeRasterizer } from '@angadie/chittie-react-native';
+
+const rasterizer = createNativeRasterizer();
+
+const bytes = render(
+  <Printer width={32}>
+    <Text align="center" bold>ආයුබෝවන්</Text>
+    <Row left="තේ" right="Rs. 250" />
+  </Printer>,
+  { dotWidth: 384, rasterizer }   // 58mm
+);
+// send `bytes` over your transport (BLE/USB/TCP)
+```
+
+The native side returns an RGBA bitmap sized to the text (dims padded to /8), which chittie packs
+to ESC/POS raster unchanged.
+
+## Architecture
+
+```
+TS:   createNativeRasterizer()  →  makeRasterizer(native)  →  chittie TextRasterizer
+      (src/index.ts)               (src/adapter.ts, pure)     (ImageData → render())
+Nitro spec: src/specs/ChittieRasterizer.nitro.ts  (rasterize → RasterBitmap{data,width,height})
+Native:  ios/HybridChittieRasterizer.swift   (UIKit/CoreText)
+         android/.../HybridChittieRasterizer.kt  (StaticLayout/Canvas)
+```
+
+`makeRasterizer` is pure and dependency-free (no Nitro import) so it's unit-testable off-device;
+`createNativeRasterizer` wires the real Nitro HybridObject.
+
+## What's verified vs gated
+
+- **Verified (off-device):** `nitro-codegen` runs and the bindings are committed under `nitrogen/`;
+  the TS adapter spike (native bitmap → `ImageData` → chittie's `padTo8`, `spikes/adapter.spike.mts`);
+  `bob build` (commonjs/module/typescript) + typecheck in the monorepo gate.
+- **Gated (needs Xcode/Android Studio + a device):** the native **Swift/Kotlin compile** and an
+  on-device snapshot of the rendered glyphs. The iOS/Android build files mirror the proven
+  `react-native-nitro-haptics` template; the device build validates them.
+
+## Roadmap (per the RFC)
+
+- Phase 1 — **rasterizer** (this).
+- Phase 2 — **read-capable BLE transport** (status via `DLE EOT` notify; see `chittie-transport`'s
+  `queryStatus`).
+- Phase 3 — **USB (Android host) + TCP** transports.
+
+## Notes
+
+- Complex shaping + bidi come from the platform engines for free (UIKit/StaticLayout), so Arabic
+  joins and reorders correctly. For RTL *rows*, also pass `rtl` to `<Row>` (see `docs/i18n.md`).
+- For font selection, the native side uses the system font (which has Sinhala/Tamil/Arabic
+  fallbacks); custom-font support is a future option.

package/android/CMakeLists.txt

@@ -0,0 +1,25 @@
+project(ChittieReactNative)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME ChittieReactNative)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/ChittieReactNative+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp")
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android
+)

package/android/build.gradle

@@ -0,0 +1,100 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply from: '../nitrogen/generated/android/ChittieReactNative+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["ChittieReactNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ChittieReactNative_" + name]).toInteger()
+}
+
+android {
+  namespace "com.chittie"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug { cppFlags "-O1 -g" }
+          release { cppFlags "-O2" }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake { path "CMakeLists.txt" }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release { minifyEnabled false }
+  }
+
+  lintOptions { disable "GradleCompatible" }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "ChittieReactNative"
+    codegenJavaPackageName = "com.chittie"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,37 @@
+tasks.configureEach { task ->
+  // Generate our prefab publication file only after building the native library so a full
+  // configuration publication (including the .so) is generated, not just a header publication.
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = rootProject.getProperties().get("reactNativeArchitectures")?.split(",") ?: ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep -> dep.group == project.group && dep.name == project.name }
+    }
+    if (!dependsOnThisLib && proj != project) return
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) return
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) prefabFile.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ChittieReactNative_kotlinVersion=2.1.20
+ChittieReactNative_minSdkVersion=24
+ChittieReactNative_targetSdkVersion=35
+ChittieReactNative_compileSdkVersion=34
+ChittieReactNative_ndkVersion=27.1.12297006

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "ChittieReactNativeOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::chittie::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/chittie/HybridChittieRasterizer.kt

@@ -0,0 +1,53 @@
+package com.margelo.nitro.chittie
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.StaticLayout
+import android.text.TextPaint
+import com.margelo.nitro.core.ArrayBuffer
+import java.nio.ByteBuffer
+import kotlin.math.ceil
+
+// Implements the nitrogen-generated HybridChittieRasterizerSpec.
+// StaticLayout shapes complex scripts (Sinhala/Tamil joining), bidi (Arabic) and
+// wrapping. We size the bitmap to the TEXT width (so chittie's ESC alignment can
+// center the image) and pad width/height to multiples of 8.
+class HybridChittieRasterizer : HybridChittieRasterizerSpec() {
+  override fun rasterize(text: String, fontSize: Double, maxWidth: Double, bold: Boolean): RasterBitmap {
+    val paint = TextPaint().apply {
+      isAntiAlias = true
+      color = Color.BLACK
+      textSize = fontSize.toFloat()
+      typeface = if (bold) Typeface.DEFAULT_BOLD else Typeface.DEFAULT
+    }
+    val maxW = maxWidth.toInt().coerceAtLeast(8)
+
+    val layout = StaticLayout.Builder
+      .obtain(text, 0, text.length, paint, maxW)
+      .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+      .setIncludePad(false)
+      .build()
+
+    fun pad8(v: Int) = (v + 7) and 7.inv()
+    var used = 0f
+    for (i in 0 until layout.lineCount) used = maxOf(used, layout.getLineWidth(i))
+    val w = pad8(ceil(used.toDouble()).toInt().coerceIn(8, maxW))
+    val h = pad8(layout.height.coerceAtLeast(8))
+
+    val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+    Canvas(bmp).apply {
+      drawColor(Color.WHITE)
+      layout.draw(this)
+    }
+
+    val bb = ByteBuffer.allocateDirect(w * h * 4)
+    bmp.copyPixelsToBuffer(bb)
+    bb.rewind()
+    bmp.recycle()
+
+    return RasterBitmap(data = ArrayBuffer.copy(bb), width = w.toDouble(), height = h.toDouble())
+  }
+}

package/app.plugin.js

@@ -0,0 +1,5 @@
+// Expo config plugin (pass-through). chittie-react-native is a Nitro native module
+// picked up by autolinking on `expo prebuild` / in a dev client — no extra native
+// config is required. This exists so it can be listed in app.json `plugins` without
+// error if a project prefers to be explicit.
+module.exports = (config) => config;

package/ios/HybridChittieRasterizer.swift

@@ -0,0 +1,48 @@
+import Foundation
+import NitroModules
+import UIKit
+
+// Implements the nitrogen-generated HybridChittieRasterizerSpec.
+// Shapes one line of text with UIKit/CoreText (complex-script shaping + bidi for
+// free) into an RGBA bitmap sized to the TEXT (so chittie's ESC alignment can
+// center the image), with width/height padded to multiples of 8.
+class HybridChittieRasterizer: HybridChittieRasterizerSpec {
+  func rasterize(text: String, fontSize: Double, maxWidth: Double, bold: Bool) throws -> RasterBitmap {
+    let font = bold
+      ? UIFont.boldSystemFont(ofSize: CGFloat(fontSize))
+      : UIFont.systemFont(ofSize: CGFloat(fontSize))
+    let attrs: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: UIColor.black]
+    let attr = NSAttributedString(string: text, attributes: attrs)
+
+    let maxW = CGFloat(max(8, maxWidth))
+    let opts: NSStringDrawingOptions = [.usesLineFragmentOrigin, .usesFontLeading]
+    let bounds = attr.boundingRect(
+      with: CGSize(width: maxW, height: .greatestFiniteMagnitude), options: opts, context: nil)
+
+    func pad8(_ v: Int) -> Int { (v + 7) & ~7 }
+    let w = max(8, pad8(Int(ceil(bounds.width)) + 2))
+    let h = max(8, pad8(Int(ceil(bounds.height)) + 2))
+
+    let bytesPerRow = w * 4
+    var pixels = [UInt8](repeating: 255, count: w * h * 4) // white, opaque
+    guard
+      let ctx = CGContext(
+        data: &pixels, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow,
+        space: CGColorSpaceCreateDeviceRGB(),
+        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)
+    else {
+      throw NSError(domain: "chittie", code: 1, userInfo: [NSLocalizedDescriptionKey: "CGContext failed"])
+    }
+
+    // UIKit draws top-left origin; flip the CG context to match.
+    UIGraphicsPushContext(ctx)
+    ctx.translateBy(x: 0, y: CGFloat(h))
+    ctx.scaleBy(x: 1, y: -1)
+    attr.draw(with: CGRect(x: 1, y: 1, width: CGFloat(w) - 2, height: CGFloat(h) - 2),
+              options: opts, context: nil)
+    UIGraphicsPopContext()
+
+    let buffer = ArrayBuffer.copy(data: Data(pixels))
+    return RasterBitmap(data: buffer, width: Double(w), height: Double(h))
+  }
+}

package/lib/commonjs/adapter.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeRasterizer = makeRasterizer;
+/**
+ * Adapt a native `ChittieRasterizer` HybridObject to chittie's `TextRasterizer`.
+ * The native side returns an RGBA bitmap (dims already padded to /8); we wrap it
+ * as the structural `ImageData` chittie's raster pipeline consumes. Pure and
+ * dependency-free at runtime (no Nitro import) — inject `native` so it's testable
+ * off-device.
+ */
+function makeRasterizer(native) {
+  return {
+    rasterize(text, options = {}) {
+      const {
+        fontSize = 24,
+        maxWidth = 576,
+        bold = false
+      } = options;
+      const b = native.rasterize(text, fontSize, maxWidth, !!bold);
+      // RGBA, structural ImageData — chittie reads { data, width, height }.
+      return {
+        data: new Uint8ClampedArray(b.data),
+        width: b.width,
+        height: b.height,
+        colorSpace: 'srgb'
+      };
+    }
+  };
+}
+//# sourceMappingURL=adapter.js.map

package/lib/commonjs/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["makeRasterizer","native","rasterize","text","options","fontSize","maxWidth","bold","b","data","Uint8ClampedArray","width","height","colorSpace"],"sourceRoot":"../../src","sources":["adapter.ts"],"mappings":";;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,cAAcA,CAACC,MAAyB,EAAkB;EACxE,OAAO;IACLC,SAASA,CAACC,IAAY,EAAEC,OAAsB,GAAG,CAAC,CAAC,EAAa;MAC9D,MAAM;QAAEC,QAAQ,GAAG,EAAE;QAAEC,QAAQ,GAAG,GAAG;QAAEC,IAAI,GAAG;MAAM,CAAC,GAAGH,OAAO;MAC/D,MAAMI,CAAC,GAAGP,MAAM,CAACC,SAAS,CAACC,IAAI,EAAEE,QAAQ,EAAEC,QAAQ,EAAE,CAAC,CAACC,IAAI,CAAC;MAC5D;MACA,OAAO;QACLE,IAAI,EAAE,IAAIC,iBAAiB,CAACF,CAAC,CAACC,IAAI,CAAC;QACnCE,KAAK,EAAEH,CAAC,CAACG,KAAK;QACdC,MAAM,EAAEJ,CAAC,CAACI,MAAM;QAChBC,UAAU,EAAE;MACd,CAAC;IACH;EACF,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNativeRasterizer = createNativeRasterizer;
+Object.defineProperty(exports, "makeRasterizer", {
+  enumerable: true,
+  get: function () {
+    return _adapter.makeRasterizer;
+  }
+});
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _adapter = require("./adapter.js");
+let cached;
+
+/**
+ * The native chittie rasterizer (CoreText / android.graphics) as a chittie
+ * `TextRasterizer` — pass it to `render()` so Sinhala/Tamil/Arabic print on a
+ * device without Skia. Requires a dev client / bare RN (native module).
+ *
+ * ```ts
+ * import { createNativeRasterizer } from '@angadie/chittie-react-native';
+ * const bytes = render(<Receipt/>, { dotWidth: 384, rasterizer: createNativeRasterizer() });
+ * ```
+ */
+function createNativeRasterizer() {
+  if (!cached) {
+    const native = _reactNativeNitroModules.NitroModules.createHybridObject('ChittieRasterizer');
+    cached = (0, _adapter.makeRasterizer)(native);
+  }
+  return cached;
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_adapter","cached","createNativeRasterizer","native","NitroModules","createHybridObject","makeRasterizer"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAGA,IAAAC,QAAA,GAAAD,OAAA;AAKA,IAAIE,MAAkC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,sBAAsBA,CAAA,EAAmB;EACvD,IAAI,CAACD,MAAM,EAAE;IACX,MAAME,MAAM,GAAGC,qCAAY,CAACC,kBAAkB,CAAoB,mBAAmB,CAAC;IACtFJ,MAAM,GAAG,IAAAK,uBAAc,EAACH,MAAM,CAAC;EACjC;EACA,OAAOF,MAAM;AACf","ignoreList":[]}

package/lib/commonjs/package.json

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

package/lib/commonjs/specs/ChittieRasterizer.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=ChittieRasterizer.nitro.js.map

package/lib/commonjs/specs/ChittieRasterizer.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ChittieRasterizer.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/adapter.js

@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * Adapt a native `ChittieRasterizer` HybridObject to chittie's `TextRasterizer`.
+ * The native side returns an RGBA bitmap (dims already padded to /8); we wrap it
+ * as the structural `ImageData` chittie's raster pipeline consumes. Pure and
+ * dependency-free at runtime (no Nitro import) — inject `native` so it's testable
+ * off-device.
+ */
+export function makeRasterizer(native) {
+  return {
+    rasterize(text, options = {}) {
+      const {
+        fontSize = 24,
+        maxWidth = 576,
+        bold = false
+      } = options;
+      const b = native.rasterize(text, fontSize, maxWidth, !!bold);
+      // RGBA, structural ImageData — chittie reads { data, width, height }.
+      return {
+        data: new Uint8ClampedArray(b.data),
+        width: b.width,
+        height: b.height,
+        colorSpace: 'srgb'
+      };
+    }
+  };
+}
+//# sourceMappingURL=adapter.js.map

package/lib/module/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["makeRasterizer","native","rasterize","text","options","fontSize","maxWidth","bold","b","data","Uint8ClampedArray","width","height","colorSpace"],"sourceRoot":"../../src","sources":["adapter.ts"],"mappings":";;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,cAAcA,CAACC,MAAyB,EAAkB;EACxE,OAAO;IACLC,SAASA,CAACC,IAAY,EAAEC,OAAsB,GAAG,CAAC,CAAC,EAAa;MAC9D,MAAM;QAAEC,QAAQ,GAAG,EAAE;QAAEC,QAAQ,GAAG,GAAG;QAAEC,IAAI,GAAG;MAAM,CAAC,GAAGH,OAAO;MAC/D,MAAMI,CAAC,GAAGP,MAAM,CAACC,SAAS,CAACC,IAAI,EAAEE,QAAQ,EAAEC,QAAQ,EAAE,CAAC,CAACC,IAAI,CAAC;MAC5D;MACA,OAAO;QACLE,IAAI,EAAE,IAAIC,iBAAiB,CAACF,CAAC,CAACC,IAAI,CAAC;QACnCE,KAAK,EAAEH,CAAC,CAACG,KAAK;QACdC,MAAM,EAAEJ,CAAC,CAACI,MAAM;QAChBC,UAAU,EAAE;MACd,CAAC;IACH;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { makeRasterizer } from './adapter.js';
+export { makeRasterizer } from './adapter.js';
+let cached;
+
+/**
+ * The native chittie rasterizer (CoreText / android.graphics) as a chittie
+ * `TextRasterizer` — pass it to `render()` so Sinhala/Tamil/Arabic print on a
+ * device without Skia. Requires a dev client / bare RN (native module).
+ *
+ * ```ts
+ * import { createNativeRasterizer } from '@angadie/chittie-react-native';
+ * const bytes = render(<Receipt/>, { dotWidth: 384, rasterizer: createNativeRasterizer() });
+ * ```
+ */
+export function createNativeRasterizer() {
+  if (!cached) {
+    const native = NitroModules.createHybridObject('ChittieRasterizer');
+    cached = makeRasterizer(native);
+  }
+  return cached;
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","makeRasterizer","cached","createNativeRasterizer","native","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,SAASC,cAAc,QAAQ,cAAc;AAE7C,SAASA,cAAc,QAAQ,cAAc;AAG7C,IAAIC,MAAkC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CAAA,EAAmB;EACvD,IAAI,CAACD,MAAM,EAAE;IACX,MAAME,MAAM,GAAGJ,YAAY,CAACK,kBAAkB,CAAoB,mBAAmB,CAAC;IACtFH,MAAM,GAAGD,cAAc,CAACG,MAAM,CAAC;EACjC;EACA,OAAOF,MAAM;AACf","ignoreList":[]}

package/lib/module/specs/ChittieRasterizer.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ChittieRasterizer.nitro.js.map

package/lib/module/specs/ChittieRasterizer.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ChittieRasterizer.nitro.ts"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,11 @@
+import type { TextRasterizer } from '@angadie/chittie-text';
+import type { ChittieRasterizer } from './specs/ChittieRasterizer.nitro.js';
+/**
+ * Adapt a native `ChittieRasterizer` HybridObject to chittie's `TextRasterizer`.
+ * The native side returns an RGBA bitmap (dims already padded to /8); we wrap it
+ * as the structural `ImageData` chittie's raster pipeline consumes. Pure and
+ * dependency-free at runtime (no Nitro import) — inject `native` so it's testable
+ * off-device.
+ */
+export declare function makeRasterizer(native: ChittieRasterizer): TextRasterizer;
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAE5E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,cAAc,CAcxE"}

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

@@ -0,0 +1,15 @@
+import type { TextRasterizer } from '@angadie/chittie-text';
+export { makeRasterizer } from './adapter.js';
+export type { ChittieRasterizer, RasterBitmap } from './specs/ChittieRasterizer.nitro.js';
+/**
+ * The native chittie rasterizer (CoreText / android.graphics) as a chittie
+ * `TextRasterizer` — pass it to `render()` so Sinhala/Tamil/Arabic print on a
+ * device without Skia. Requires a dev client / bare RN (native module).
+ *
+ * ```ts
+ * import { createNativeRasterizer } from '@angadie/chittie-react-native';
+ * const bytes = render(<Receipt/>, { dotWidth: 384, rasterizer: createNativeRasterizer() });
+ * ```
+ */
+export declare function createNativeRasterizer(): TextRasterizer;
+//# 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.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAI1F;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,IAAI,cAAc,CAMvD"}

package/lib/typescript/src/specs/ChittieRasterizer.nitro.d.ts

@@ -0,0 +1,23 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * An RGBA bitmap. `width`/`height` are padded to multiples of 8 on the native
+ * side so chittie's ESC/POS raster packer (`padTo8`) is a no-op.
+ */
+export interface RasterBitmap {
+    data: ArrayBuffer;
+    width: number;
+    height: number;
+}
+/**
+ * Native text rasterizer — shapes a line with the platform text engine
+ * (CoreText on iOS, android.graphics on Android), which handles complex-script
+ * shaping (Sinhala/Tamil joining) and bidi (Arabic/Hebrew) for free.
+ */
+export interface ChittieRasterizer extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /** Render `text` to an RGBA bitmap (black on white), wrapped at `maxWidth` dots. */
+    rasterize(text: string, fontSize: number, maxWidth: number, bold: boolean): RasterBitmap;
+}
+//# sourceMappingURL=ChittieRasterizer.nitro.d.ts.map

package/lib/typescript/src/specs/ChittieRasterizer.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChittieRasterizer.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/ChittieRasterizer.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAC1F,oFAAoF;IACpF,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC;CAC1F"}