@rejaul/react-native-rust 1.0.2 → 2.0.0

package/README.md

@@ -4,11 +4,22 @@ Generate Rust functions and native bindings from a React Native TurboModule Type
 
 The CLI currently targets the **C++ TurboModule** template created by [`create-react-native-library`](https://www.npmjs.com/package/create-react-native-library).
 
+## Screenshots
+
+The generated [`react-native-awesome-library-example`](react-native-awesome-library-example) app calling every generated method and rendering its live Rust result, on all three platforms:
+
+| Android | iOS | Web |
+| --- | --- | --- |
+| ![Android screenshot](doc/screenshots/android.png) | ![iOS screenshot](doc/screenshots/ios.png) | ![Web screenshot](doc/screenshots/web.png) |
+
 ## Contents
 
+- [Screenshots](#screenshots)
 - [Requirements](#requirements)
 - [Create a library](#create-a-library)
 - [Add Rust functions](#add-rust-functions)
+- [Use Rust in an app](#use-rust-in-an-app)
+- [Automatic development mode](#automatic-development-mode)
 - [Build and run](#build-and-run)
 - [Supported types](#supported-types)
 - [Publish](#publish)
@@ -24,6 +35,7 @@ The CLI currently targets the **C++ TurboModule** template created by [`create-r
 - Rust stable (`rustup`, `cargo`).
 - Android builds: Android SDK/NDK and `cargo-ndk`.
 - iOS builds: macOS, Xcode command-line tools, and the Rust Apple targets.
+- Web builds (`react-native-web`): [`wasm-pack`](https://rustwasm.github.io/wasm-pack/) and the `wasm32-unknown-unknown` Rust target (`rustup target add wasm32-unknown-unknown`).
 
 ## Create a library
 
@@ -42,10 +54,10 @@ cd react-native-awesome-library
 yarn install
 ```
 
-To run the CLI from its source checkout before publishing, use the checkout's path from the desired parent folder:
+To run the CLI from its source checkout before publishing, build it once (`npm run build` from the checkout root), then invoke the compiled output by path from the desired parent folder:
 
 ```sh
-node /path/to/rust_to_cpp/bin/react-native-rust.js create react-native-awesome-library
+node /path/to/rust_to_cpp/dist/react-native-rust.js create react-native-awesome-library
 ```
 
 To add Rust support to an existing C++ TurboModule library, install the CLI and initialize it from that library's root:
@@ -89,6 +101,89 @@ Run Rust tests with:
 yarn rust:test
 ```
 
+## Use Rust in an app
+
+For app-specific Rust code, run the CLI from the root of an existing React Native Community CLI app that has both `android/` and `ios/` folders:
+
+```sh
+npx react-native-rust init --app
+npm install
+```
+
+The command creates a private local TurboModule package in `.rust-native/` (hidden, generated C++/TurboModule glue only — never hand-edit it), and puts the Rust crate itself at the app's own root, `rust/`, alongside `android/` and `ios/`. It adds `.rust-native/` to the app as a local dependency and generates its C++ bridge. It does not publish a separate library. App-local mode currently supports C++ TurboModule apps with both Android and iOS projects.
+
+```
+my-app/
+├── rust/                ← edit this: your Rust crate
+│   ├── Cargo.toml
+│   └── src/api/
+├── .rust-native/         ← generated TurboModule glue; do not edit
+├── android/
+├── ios/
+└── package.json
+```
+
+Edit `.rust-native/src/NativeRustApp.ts` to declare methods, then implement their generated handlers under `rust/src/api/`. From the app root, regenerate the bindings and React Native Codegen output with:
+
+```sh
+npm run rust:generate
+```
+
+Build the Rust archive for the target platform, then build and launch the React Native app:
+
+```sh
+npm run rust:build:android
+npx react-native run-android
+```
+
+For iOS, build the XCFramework, install Pods, then launch the app:
+
+```sh
+npm run rust:build:ios
+cd ios && pod install && cd ..
+npx react-native run-ios
+```
+
+The generated module is app-local and can be used from the app's JavaScript imports. The root `example/` project in this repository exercises this workflow.
+
+## Automatic development mode
+
+The commands above (`rust:generate`, `rust:build:*`) still work exactly as before and remain fully supported. For day-to-day development, `react-native-rust watch` runs instead, watching the `Spec` and `rust/` and reacting automatically:
+
+```
+Legacy workflow:  init → generate → build (repeated by hand after every change)
+New workflow:     init once → npx react-native-rust watch (or npx react-native start, with Metro integration below)
+```
+
+On every save, the watcher classifies the change and reacts accordingly, matching what a manual run of `generate`/`build` would already produce:
+
+- **A Rust file under `rust/src/`, or `Cargo.toml`/`Cargo.lock`, changes** (an implementation-only edit): it runs an incremental `cargo build` only. Native bindings are not regenerated.
+- **The `Spec` file changes** (a new method, or a signature change): it runs `generate()` first — preserving hand-written Rust handler bodies, exactly like running `rust:generate` by hand — and then `cargo build`.
+- Rapid successive saves are debounced and coalesced into one build; a build already in progress is never interrupted, and at most one more run is queued behind it.
+- A failed build or a failed code generation prints the error and keeps watching; it does not crash the process or leave stale generated files.
+
+Run it directly:
+
+```sh
+npx react-native-rust watch
+```
+
+Or wire it into Metro so `npx react-native start` runs it automatically:
+
+```js
+// metro.config.js
+const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
+const { withRust } = require('@rejaul/react-native-rust/metro');
+
+module.exports = withRust(mergeConfig(getDefaultConfig(__dirname), {}));
+```
+
+`withRust()` detects your Rust project automatically at `rust/` (both library mode and app-local mode keep it at the project root) and adds it to `watchFolders`; pass `{ rustDir: './rust' }` only if your Rust project lives somewhere non-standard. It starts the watcher only while Metro's dev server is actually serving requests — never during a production/release bundle — and its `[Rust]`/`[RN Rust]` output streams into the same terminal as Metro's own. If Rust hasn't been initialized yet, it no-ops with a one-line notice instead of erroring, so it's safe to add before running `init`.
+
+If Metro integration isn't wired up (or doesn't fit your setup), run `npx react-native-rust watch` in a separate terminal alongside `npx react-native start` — it does the same thing standalone.
+
+**What this does not do:** Rust and C++ are native code. A running Android/iOS app cannot hot-swap a rebuilt native library the way Metro hot-swaps JavaScript. Each cycle rebuilds the Rust crate and prints a reminder that you still need to run `npm run rust:build:ios` / `rust:build:android` and reinstall the app to load the change on a simulator or device. A `Spec` change also regenerates `src/rust-generated.native.tsx`, which Metro's own JS watcher will pick up and Fast Refresh on its own, same as any other JS/TS change.
+
 ## Build and run
 
 Run these commands from the library root. Generate TurboModule Codegen output with `yarn prepare` before building the host app.
@@ -150,6 +245,30 @@ Rust outputs are written under `rust/build/` and included in the generated libra
 
 The example screen in `example/src/App.tsx` exercises the supported scalar, JSON, Promise, and callback signatures.
 
+### Web
+
+Install `wasm-pack` and the `wasm32-unknown-unknown` target once:
+
+```sh
+cargo install wasm-pack
+rustup target add wasm32-unknown-unknown
+```
+
+Build the WebAssembly package:
+
+```sh
+yarn rust:build:web
+```
+
+This compiles `rust/` to `rust/build/web/pkg/` with `wasm-pack build --target web`, reusing the same `rust/src/api/<method>.rs` handlers as native — no separate implementation is needed. It replaces the generated `src/rust-generated.tsx` module (used by web bundlers that don't understand Metro's `.native.` file convention, such as Vite or webpack) with a real, WASM-backed implementation instead of the "not supported on native platforms" stub used before this module exists. Call and await its exported `initRustWeb()` once before using any generated function on web, since loading a `.wasm` file is asynchronous:
+
+```ts
+import { initRustWeb, multiply } from 'react-native-awesome-library';
+
+await initRustWeb();
+multiply(3, 7); // 21
+```
+
 ## Supported types
 
 The generator supports these TypeScript-to-Rust/C++ mappings:
@@ -169,6 +288,8 @@ Arrays and `UnsafeObject` values cross the native boundary as JSON, so their con
 
 Typed object structs, optional or rest parameters, destructured parameters, generic methods, and overloads are not supported. Unsupported signatures fail before generated files are changed.
 
+The same mappings apply on `react-native-web`: values cross as JSON strings via `wasm-bindgen` instead of the JSI C++ bridge, and callback parameters are passed as a JS function. See [Web](#web) for the build step and the async `initRustWeb()` call it requires.
+
 ## Publish
 
 Before publishing a generated React Native library, generate its TypeScript/native outputs and build the Rust artifacts for the platforms you intend to ship:
@@ -177,6 +298,7 @@ Before publishing a generated React Native library, generate its TypeScript/nati
 yarn prepare
 yarn rust:build:ios
 yarn rust:build:android
+yarn rust:build:web
 npm pack --dry-run
 ```
 
@@ -196,7 +318,12 @@ Pushing a version tag such as `v1.0.2` runs [`.github/workflows/publish.yml`](.g
 - Android CMake cannot find `android/generated/jni`: run `yarn prepare` from the library root.
 - Android CMake cannot find a Rust `.a` archive: run `yarn rust:build:android` before launching the example.
 - iOS reports a missing Rust XCFramework: run `yarn rust:build:ios`, then `pod install` in `example/ios`.
+- `wasm-pack: command not found`: install it with `cargo install wasm-pack`, or run `react-native-rust doctor web` to check both prerequisites.
+- The web app throws "Call and await initRustWeb()...": await `initRustWeb()` once before calling any other generated function; loading the `.wasm` file is asynchronous even though the generated calls are not.
 - A React Native type is reported as unsupported: check the mappings and signature restrictions in [Supported types](#supported-types).
+- `react-native-rust watch` prints "Rust is not initialized": run `react-native-rust init` (or `init --app`) first; the watcher requires `rust/Cargo.toml` to exist.
+- Changes made in a running app never appear, even after "`[Rust] Build completed`": native code cannot hot-swap into a running process. Run `npm run rust:build:ios` / `rust:build:android` and reinstall the app, as [Automatic development mode](#automatic-development-mode) describes.
+- `npx react-native start` doesn't print any `[Rust]` lines: confirm `metro.config.js` calls `withRust(...)` and that `rust/Cargo.toml` exists at the project root; otherwise run `npx react-native-rust watch` in a separate terminal.
 
 ## Contributing
 

package/dist/app.js

@@ -0,0 +1,285 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_exports = {};
+__export(app_exports, {
+  appModuleRoot: () => appModuleRoot,
+  inDirectory: () => inDirectory,
+  initApp: () => initApp,
+  runCodegen: () => runCodegen
+});
+module.exports = __toCommonJS(app_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_react_native_rust_lib = require("./react-native-rust-lib");
+const moduleDirectory = ".rust-native";
+const moduleName = "RustApp";
+const packageName = "rust-app-native-module";
+function writeFiles(root, files) {
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const outputPath = import_node_path.default.join(root, relativePath);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputPath), { recursive: true });
+    import_node_fs.default.writeFileSync(outputPath, contents);
+  }
+}
+function scaffoldFiles(appName) {
+  const javaPackageName = appName.replace(/([a-z0-9])([A-Z])/g, "$1.$2").replace(/[^a-zA-Z0-9]+/g, ".").replace(/^\.+|\.+$/g, "").toLowerCase() || "com.rustapp";
+  return {
+    "package.json": `${JSON.stringify({
+      name: packageName,
+      version: "0.0.1",
+      description: "App-local Rust TurboModule",
+      main: "src/index.tsx",
+      "react-native": "src/index.tsx",
+      types: "src/index.tsx",
+      files: ["src/", "cpp/", "android/", "ios/", "*.podspec", "react-native.config.js"],
+      peerDependencies: { react: "*", "react-native": ">=0.76" },
+      codegenConfig: {
+        name: `${moduleName}Spec`,
+        type: "modules",
+        jsSrcsDir: "src",
+        outputDir: { ios: "ios/generated", android: "android/generated" },
+        android: { javaPackageName },
+        includesGeneratedCode: true
+      },
+      // The Rust crate lives at the app's own root, not inside this generated module package.
+      reactNativeRust: { rustDir: "../rust" }
+    }, null, 2)}
+`,
+    "react-native.config.js": `module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath: 'generated/jni/CMakeLists.txt',
+        cxxModuleCMakeListsModuleName: '${packageName}',
+        cxxModuleCMakeListsPath: 'CMakeLists.txt',
+        cxxModuleHeaderName: '${moduleName}Impl',
+      },
+    },
+  },
+};
+`,
+    [`${moduleName}.podspec`]: `Pod::Spec.new do |s|
+  s.name = "${moduleName}"
+  s.version = "0.0.1"
+  s.summary = "App-local Rust TurboModule"
+  s.homepage = "https://example.invalid"
+  s.license = "MIT"
+  s.author = "Local app"
+  s.source = { :git => "https://example.invalid" }
+  s.platforms = { :ios => min_ios_version_supported }
+  s.source_files = "cpp/**/*.{hpp,cpp,c,h}", "ios/**/*.{h,m,mm}", "ios/generated/*.{h,cpp,mm}"
+  install_modules_dependencies(s)
+end
+`,
+    // rust-include, rust-build-android, rust-build-ios: generated by `init`/`build` to reach
+    // the Rust crate at the app's own root (see resolveOutsideReference) — a real symlink or, for
+    // iOS, a copied build artifact, never hand-authored.
+    ".gitignore": "node_modules/\nrust-include\nrust-build-android\nrust-build-ios\nrust-build-web-pkg\n",
+    "src/NativeRustApp.ts": `import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiply(a: number, b: number): number;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('${moduleName}');
+`,
+    "src/index.tsx": "export * from './rust-generated';\n",
+    "cpp/RustAppImpl.h": `#pragma once
+
+#include <${moduleName}SpecJSI.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+class ${moduleName}Impl : public Native${moduleName}CxxSpec<${moduleName}Impl> {
+public:
+  ${moduleName}Impl(std::shared_ptr<CallInvoker> jsInvoker);
+  double multiply(jsi::Runtime& rt, double a, double b);
+};
+
+}
+`,
+    "cpp/RustAppImpl.cpp": `#include "RustAppImpl.h"
+
+namespace facebook::react {
+
+${moduleName}Impl::${moduleName}Impl(std::shared_ptr<CallInvoker> jsInvoker)
+  : Native${moduleName}CxxSpec(std::move(jsInvoker)) {}
+
+double ${moduleName}Impl::multiply(jsi::Runtime&, double a, double b) {
+  return a * b;
+}
+
+}
+`,
+    "android/CMakeLists.txt": `cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+add_library(
+  ${packageName}
+  STATIC
+  ../cpp/${moduleName}Impl.cpp
+)
+
+set_target_properties(
+  ${packageName} PROPERTIES
+  CXX_STANDARD 20
+  CXX_STANDARD_REQUIRED ON
+  CXX_EXTENSIONS OFF
+)
+
+target_include_directories(${packageName} PUBLIC ../cpp)
+
+target_link_libraries(
+  ${packageName}
+  jsi
+  reactnative
+  react_codegen_${moduleName}Spec
+)
+`,
+    "ios/OnLoad.mm": `#import <Foundation/Foundation.h>
+#import "${moduleName}Impl.h"
+#import <ReactCommon/CxxTurboModuleUtils.h>
+
+@interface ${moduleName}OnLoad : NSObject
+@end
+
+@implementation ${moduleName}OnLoad
+
+using namespace facebook::react;
+
++ (void)load
+{
+  registerCxxModuleToGlobalModuleMap(
+    std::string(${moduleName}Impl::kModuleName),
+    [](std::shared_ptr<CallInvoker> jsInvoker) {
+      return std::make_shared<${moduleName}Impl>(jsInvoker);
+    }
+  );
+}
+
+@end
+`
+  };
+}
+function appModuleRoot(appRoot = process.cwd()) {
+  const moduleRoot = import_node_path.default.join(appRoot, moduleDirectory);
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(moduleRoot, "package.json"))) return null;
+  return import_node_fs.default.existsSync(import_node_path.default.join(appRoot, "rust", "Cargo.toml")) ? moduleRoot : null;
+}
+function inDirectory(directory, callback) {
+  const previousDirectory = process.cwd();
+  process.chdir(directory);
+  try {
+    return callback();
+  } finally {
+    process.chdir(previousDirectory);
+  }
+}
+function runCodegen(appRoot, moduleRoot) {
+  const script = import_node_path.default.join(appRoot, "node_modules", "react-native", "scripts", "generate-codegen-artifacts.js");
+  if (!import_node_fs.default.existsSync(script)) {
+    throw new Error("React Native dependencies are missing. Install the app dependencies, then run `react-native-rust generate`.");
+  }
+  const result = (0, import_node_child_process.spawnSync)(process.execPath, [script, "-p", moduleRoot, "-t", "all", "-s", "library"], {
+    cwd: appRoot,
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`React Native Codegen failed: ${(result.stderr || result.stdout || result.error?.message || "").trim()}`);
+  }
+}
+function initApp() {
+  const appRoot = process.cwd();
+  const appManifestPath = import_node_path.default.join(appRoot, "package.json");
+  if (!import_node_fs.default.existsSync(appManifestPath)) throw new Error("Run `react-native-rust init --app` from a React Native app root.");
+  const appManifest = (0, import_react_native_rust_lib.readJson)(appManifestPath);
+  if (!(appManifest.dependencies || {})["react-native"]) throw new Error("This project does not declare react-native as a dependency.");
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(appRoot, "android")) || !import_node_fs.default.existsSync(import_node_path.default.join(appRoot, "ios"))) {
+    throw new Error("App-local Rust currently requires both Android and iOS native project folders.");
+  }
+  const moduleRoot = import_node_path.default.join(appRoot, moduleDirectory);
+  if (import_node_fs.default.existsSync(moduleRoot)) throw new Error(`${moduleDirectory} already exists; no files were changed.`);
+  import_node_fs.default.mkdirSync(moduleRoot, { recursive: true });
+  try {
+    writeFiles(moduleRoot, scaffoldFiles(appManifest.name || "rust-app"));
+    inDirectory(moduleRoot, import_react_native_rust_lib.init);
+    const cliManifest = (0, import_react_native_rust_lib.readJson)(import_node_path.default.join(__dirname, "..", "package.json"));
+    const cliRoot = import_node_path.default.resolve(__dirname, "..");
+    const cliIsInstalled = cliRoot.split(import_node_path.default.sep).includes("node_modules");
+    const cliDependency = cliIsInstalled ? `^${cliManifest.version}` : `file:${import_node_path.default.relative(appRoot, cliRoot).split(import_node_path.default.sep).join("/") || "."}`;
+    const moduleManifestPath = import_node_path.default.join(moduleRoot, "package.json");
+    const moduleManifest = (0, import_react_native_rust_lib.readJson)(moduleManifestPath);
+    delete moduleManifest.devDependencies?.[cliManifest.name];
+    import_node_fs.default.writeFileSync(moduleManifestPath, `${JSON.stringify(moduleManifest, null, 2)}
+`);
+    appManifest.dependencies = {
+      ...appManifest.dependencies,
+      [packageName]: `file:./${moduleDirectory.split(import_node_path.default.sep).join("/")}`
+    };
+    appManifest.devDependencies = {
+      ...appManifest.devDependencies,
+      [cliManifest.name]: appManifest.devDependencies?.[cliManifest.name] || cliDependency
+    };
+    appManifest.scripts = {
+      ...appManifest.scripts,
+      "rust:generate": "react-native-rust generate",
+      "rust:build:ios": "react-native-rust build ios",
+      "rust:build:android": "react-native-rust build android",
+      "rust:test": "cargo test --manifest-path rust/Cargo.toml"
+    };
+    runCodegen(appRoot, moduleRoot);
+    import_node_fs.default.writeFileSync(appManifestPath, `${JSON.stringify(appManifest, null, 2)}
+`);
+    const gitignorePath = import_node_path.default.join(appRoot, ".gitignore");
+    const gitignore = import_node_fs.default.existsSync(gitignorePath) ? import_node_fs.default.readFileSync(gitignorePath, "utf8") : "";
+    const ignoredRustOutputs = ["rust/target/", "rust/build/"].filter((entry) => !gitignore.split(/\r?\n/).includes(entry));
+    if (ignoredRustOutputs.length > 0) {
+      const separator = gitignore.length > 0 && !gitignore.endsWith("\n") ? "\n" : "";
+      import_node_fs.default.writeFileSync(gitignorePath, `${gitignore}${separator}${ignoredRustOutputs.join("\n")}
+`);
+    }
+  } catch (error) {
+    import_node_fs.default.rmSync(moduleRoot, { recursive: true, force: true });
+    import_node_fs.default.rmSync(import_node_path.default.join(appRoot, "rust"), { recursive: true, force: true });
+    throw error;
+  }
+  console.log("Created app-local Rust TurboModule: edit rust/src/api/, glue lives in .rust-native/ (generated, do not edit).");
+  console.log("Install app dependencies, then run `npm run rust:build:android` or `npm run rust:build:ios`.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appModuleRoot,
+  inDirectory,
+  initApp,
+  runCodegen
+});

package/dist/codegen/constants.js

@@ -0,0 +1,168 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  HEADER_END: () => HEADER_END,
+  HEADER_START: () => HEADER_START,
+  SOURCE_END: () => SOURCE_END,
+  SOURCE_START: () => SOURCE_START,
+  cppKeywords: () => cppKeywords,
+  rustKeywords: () => rustKeywords,
+  supportedTypes: () => supportedTypes,
+  ts: () => import_typescript.default
+});
+module.exports = __toCommonJS(constants_exports);
+var import_typescript = __toESM(require("typescript"));
+const HEADER_START = "// react-native-rust:generated-methods:start";
+const HEADER_END = "// react-native-rust:generated-methods:end";
+const SOURCE_START = "// react-native-rust:generated-methods:start";
+const SOURCE_END = "// react-native-rust:generated-methods:end";
+const rustKeywords = /* @__PURE__ */ new Set([
+  "as",
+  "async",
+  "await",
+  "break",
+  "const",
+  "continue",
+  "crate",
+  "dyn",
+  "else",
+  "enum",
+  "extern",
+  "false",
+  "fn",
+  "for",
+  "if",
+  "impl",
+  "in",
+  "let",
+  "loop",
+  "match",
+  "mod",
+  "move",
+  "mut",
+  "pub",
+  "ref",
+  "return",
+  "self",
+  "Self",
+  "static",
+  "struct",
+  "super",
+  "trait",
+  "true",
+  "type",
+  "unsafe",
+  "use",
+  "where",
+  "while"
+]);
+const cppKeywords = /* @__PURE__ */ new Set([
+  "alignas",
+  "alignof",
+  "and",
+  "asm",
+  "auto",
+  "bool",
+  "break",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "explicit",
+  "export",
+  "extern",
+  "false",
+  "float",
+  "for",
+  "friend",
+  "goto",
+  "if",
+  "inline",
+  "int",
+  "long",
+  "namespace",
+  "new",
+  "noexcept",
+  "not",
+  "nullptr",
+  "operator",
+  "or",
+  "private",
+  "protected",
+  "public",
+  "register",
+  "return",
+  "short",
+  "signed",
+  "sizeof",
+  "static",
+  "struct",
+  "switch",
+  "template",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "xor"
+]);
+const supportedTypes = /* @__PURE__ */ new Map([
+  [import_typescript.default.SyntaxKind.NumberKeyword, { kind: "number", typescript: "number", rust: "f64", cpp: "double", defaultValue: "0.0" }],
+  [import_typescript.default.SyntaxKind.BooleanKeyword, { kind: "boolean", typescript: "boolean", rust: "bool", cpp: "bool", defaultValue: "false" }],
+  [import_typescript.default.SyntaxKind.StringKeyword, { kind: "json", typescript: "string", rust: "String", cpp: "jsi::String", defaultValue: "String::new()" }],
+  [import_typescript.default.SyntaxKind.VoidKeyword, { kind: "void", typescript: "void", rust: "()", cpp: "void", defaultValue: null }]
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HEADER_END,
+  HEADER_START,
+  SOURCE_END,
+  SOURCE_START,
+  cppKeywords,
+  rustKeywords,
+  supportedTypes,
+  ts
+});

package/dist/codegen/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+__export(codegen_exports, {
+  parseSpec: () => import_spec.parseSpec,
+  renderProjectBindings: () => import_project.renderProjectBindings,
+  renderRustFfiModule: () => import_renderers.renderRustFfiModule,
+  resolveOutsideReference: () => import_project.resolveOutsideReference,
+  toPosixRelative: () => import_project.toPosixRelative
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_spec = require("./spec");
+var import_renderers = require("./renderers");
+var import_project = require("./project");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSpec,
+  renderProjectBindings,
+  renderRustFfiModule,
+  resolveOutsideReference,
+  toPosixRelative
+});