@rejaul/react-native-rust 1.0.1 → 1.1.1

package/dist/codegen/spec.js

@@ -0,0 +1,158 @@
+"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 spec_exports = {};
+__export(spec_exports, {
+  callbackInfo: () => callbackInfo,
+  parseSpec: () => parseSpec,
+  toSnakeCase: () => toSnakeCase,
+  typeInfo: () => typeInfo,
+  validateIdentifier: () => validateIdentifier
+});
+module.exports = __toCommonJS(spec_exports);
+var import_constants = require("./constants");
+function typeInfo(typeNode, sourceFile, methodName, role) {
+  const info = import_constants.supportedTypes.get(typeNode.kind);
+  if (info && !(role === "parameter" && typeNode.kind === import_constants.ts.SyntaxKind.VoidKeyword)) return info;
+  if (role === "return" && import_constants.ts.isTypeReferenceNode(typeNode) && typeNode.typeName.getText(sourceFile) === "Promise") {
+    if (typeNode.typeArguments?.length !== 1) throw new Error(`Promise return in ${methodName}() must declare one result type.`);
+    const result = typeInfo(typeNode.typeArguments[0], sourceFile, methodName, "promise result");
+    if (result.promise) {
+      throw new Error(`Nested Promise or callback results are not supported in ${methodName}().`);
+    }
+    return { ...result, typescript: typeNode.getText(sourceFile), promise: true };
+  }
+  const typeName = import_constants.ts.isTypeReferenceNode(typeNode) ? typeNode.typeName.getText(sourceFile) : "";
+  const objectType = typeNode.kind === import_constants.ts.SyntaxKind.ObjectKeyword || ["CodegenTypes.UnsafeObject", "UnsafeObject"].includes(typeName);
+  if (objectType) {
+    return {
+      kind: "json",
+      typescript: typeNode.getText(sourceFile),
+      rust: "serde_json::Value",
+      cpp: "jsi::Object",
+      defaultValue: "serde_json::json!({})"
+    };
+  }
+  const arrayElement = import_constants.ts.isArrayTypeNode(typeNode) ? typeNode.elementType : import_constants.ts.isTypeReferenceNode(typeNode) && ["Array", "ReadonlyArray"].includes(typeNode.typeName.getText(sourceFile)) && typeNode.typeArguments?.length === 1 ? typeNode.typeArguments[0] : null;
+  if (arrayElement) {
+    const elementType = typeInfo(arrayElement, sourceFile, methodName, "array element");
+    if (elementType.promise || elementType.kind === "void") {
+      throw new Error(`Unsupported array element type in ${methodName}().`);
+    }
+    return {
+      kind: "json",
+      typescript: typeNode.getText(sourceFile),
+      rust: "serde_json::Value",
+      cpp: "jsi::Array",
+      defaultValue: "serde_json::json!([])"
+    };
+  }
+  const text = typeNode.getText(sourceFile);
+  throw new Error(`Unsupported ${role} type "${text}" in ${methodName}(). Supported types are number, boolean, string, arrays, and CodegenTypes.UnsafeObject${role === "return" ? ", plus void and Promise<T>" : ""}.`);
+}
+function callbackInfo(typeNode, sourceFile, methodName) {
+  if (!import_constants.ts.isFunctionTypeNode(typeNode) || typeNode.typeParameters?.length) {
+    throw new Error(`Unsupported callback signature in ${methodName}().`);
+  }
+  if (typeNode.type.kind !== import_constants.ts.SyntaxKind.VoidKeyword || typeNode.parameters.length > 4) {
+    throw new Error(`Callbacks in ${methodName}() must return void and have at most four parameters.`);
+  }
+  const params = typeNode.parameters.map((parameter) => {
+    if (!import_constants.ts.isIdentifier(parameter.name) || parameter.questionToken || parameter.dotDotDotToken || !parameter.type) {
+      throw new Error(`Callback parameters in ${methodName}() must be named, required, and explicitly typed.`);
+    }
+    const info = typeInfo(parameter.type, sourceFile, methodName, "callback parameter");
+    if (info.promise || info.kind === "void") {
+      throw new Error(`Unsupported callback parameter type in ${methodName}().`);
+    }
+    return { name: parameter.name.text, ...info };
+  });
+  return { kind: "callback", typescript: typeNode.getText(sourceFile), cpp: "jsi::Function", params };
+}
+function toSnakeCase(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function validateIdentifier(name, location) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) || import_constants.rustKeywords.has(name) || import_constants.cppKeywords.has(name)) {
+    throw new Error(`Unsupported identifier "${name}" in ${location}; use a non-keyword identifier.`);
+  }
+}
+function parseSpec(sourceText, fileName = "NativeModule.ts") {
+  const sourceFile = import_constants.ts.createSourceFile(fileName, sourceText, import_constants.ts.ScriptTarget.Latest, true, import_constants.ts.ScriptKind.TS);
+  if (sourceFile.parseDiagnostics.length > 0) {
+    const diagnostic = sourceFile.parseDiagnostics[0];
+    throw new Error(`Could not parse ${fileName}: ${import_constants.ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`);
+  }
+  const spec = sourceFile.statements.find((statement) => import_constants.ts.isInterfaceDeclaration(statement) && statement.name.text === "Spec");
+  if (!spec) throw new Error(`No "Spec" interface was found in ${fileName}.`);
+  if (spec.typeParameters?.length) throw new Error("Generic TurboModule Spec interfaces are not supported.");
+  if (spec.members.length === 0) throw new Error("The Spec interface must declare at least one method.");
+  const names = /* @__PURE__ */ new Set();
+  const rustNames = /* @__PURE__ */ new Set();
+  const methods = spec.members.map((member) => {
+    if (!import_constants.ts.isMethodSignature(member)) {
+      throw new Error("Only method signatures are supported in the Spec interface.");
+    }
+    if (!member.name || !import_constants.ts.isIdentifier(member.name) || member.questionToken || member.typeParameters?.length) {
+      throw new Error("Optional, computed, and generic Spec methods are not supported.");
+    }
+    const name = member.name.text;
+    validateIdentifier(name, "Spec method");
+    if (names.has(name)) throw new Error(`Overloaded method "${name}" is not supported.`);
+    names.add(name);
+    const rustName = toSnakeCase(name);
+    validateIdentifier(rustName, `Rust mapping for ${name}()`);
+    if (rustNames.has(rustName)) throw new Error(`Multiple Spec methods map to the Rust name "${rustName}".`);
+    rustNames.add(rustName);
+    const params = member.parameters.map((parameter) => {
+      if (!import_constants.ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.questionToken || parameter.initializer) {
+        throw new Error(`Rest, optional, and destructured parameters are not supported in ${name}().`);
+      }
+      const paramName = parameter.name.text;
+      validateIdentifier(paramName, `parameter in ${name}()`);
+      if (!parameter.type) throw new Error(`Parameter "${paramName}" in ${name}() needs an explicit type.`);
+      const info = import_constants.ts.isFunctionTypeNode(parameter.type) ? callbackInfo(parameter.type, sourceFile, name) : typeInfo(parameter.type, sourceFile, name, "parameter");
+      return { name: paramName, ...info };
+    });
+    if (new Set(params.map((param) => param.name)).size !== params.length) {
+      throw new Error(`Duplicate parameter names are not supported in ${name}().`);
+    }
+    if (!member.type) throw new Error(`Method "${name}()" needs an explicit return type.`);
+    return {
+      name,
+      rustName,
+      symbol: `rnrs_${rustName}`,
+      params,
+      returnType: typeInfo(member.type, sourceFile, name, "return")
+    };
+  });
+  for (const method of methods) {
+    if (method.returnType.promise && method.params.some((param) => param.kind === "callback")) {
+      throw new Error(`Callbacks in Promise method ${method.name}() are not supported. Use a Codegen event emitter for asynchronous callbacks.`);
+    }
+  }
+  return methods;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callbackInfo,
+  parseSpec,
+  toSnakeCase,
+  typeInfo,
+  validateIdentifier
+});

package/dist/codegen/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/codegen.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+module.exports = __toCommonJS(codegen_exports);
+__reExport(codegen_exports, require("./codegen/index"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./codegen/index")
+});

package/dist/react-native-rust-lib.js

@@ -0,0 +1,388 @@
+"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 react_native_rust_lib_exports = {};
+__export(react_native_rust_lib_exports, {
+  build: () => build,
+  doctor: () => doctor,
+  generate: () => generate,
+  init: () => init,
+  packageRoot: () => packageRoot,
+  readJson: () => readJson,
+  run: () => run
+});
+module.exports = __toCommonJS(react_native_rust_lib_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_codegen = require("./codegen");
+const rustDirectory = "rust";
+const iosTargets = ["aarch64-apple-ios", "aarch64-apple-ios-sim", "x86_64-apple-ios"];
+const androidTargets = [
+  ["arm64-v8a", "aarch64-linux-android"],
+  ["armeabi-v7a", "armv7-linux-androideabi"],
+  ["x86", "i686-linux-android"],
+  ["x86_64", "x86_64-linux-android"]
+];
+function run(command, args, options = {}) {
+  const result = (0, import_node_child_process.spawnSync)(command, args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: "utf8",
+    stdio: options.inherit ? "inherit" : "pipe"
+  });
+  if (result.error) return { ok: false, message: result.error.message };
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      message: (result.stderr || result.stdout || `${command} exited with ${result.status}`).trim()
+    };
+  }
+  return { ok: true, output: (result.stdout || "").trim() };
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Cannot read ${filePath}: ${error.message}`, { cause: error });
+  }
+}
+function packageRoot() {
+  const root = process.cwd();
+  const manifestPath = import_node_path.default.join(root, "package.json");
+  if (!import_node_fs.default.existsSync(manifestPath)) {
+    throw new Error("Run this command from the root of a React Native library.");
+  }
+  const manifest = readJson(manifestPath);
+  const dependencies = { ...manifest.dependencies, ...manifest.peerDependencies };
+  if (!dependencies["react-native"]) {
+    throw new Error("This package does not declare react-native as a dependency or peer dependency.");
+  }
+  const configPath = import_node_path.default.join(root, "react-native.config.js");
+  if (!import_node_fs.default.existsSync(configPath)) {
+    throw new Error("Missing react-native.config.js. Create the library with the C++ module template.");
+  }
+  const config = import_node_fs.default.readFileSync(configPath, "utf8");
+  const moduleMatch = config.match(/cxxModuleHeaderName\s*:\s*['"]([a-zA-Z0-9_]+)Impl['"]/);
+  if (!moduleMatch || !config.includes("cxxModuleCMakeListsPath")) {
+    throw new Error("The library is not configured as a C++ TurboModule. Choose the C++ module template.");
+  }
+  return { root, manifest, manifestPath, moduleName: moduleMatch[1] };
+}
+function readCrateName(rustRoot) {
+  const manifestPath = import_node_path.default.join(rustRoot, "Cargo.toml");
+  const cargoManifest = import_node_fs.default.readFileSync(manifestPath, "utf8");
+  const crateMatch = cargoManifest.match(/^name\s*=\s*"([a-zA-Z0-9_-]+)"/m);
+  if (!crateMatch) throw new Error("Could not read the Rust crate name from rust/Cargo.toml.");
+  return crateMatch[1];
+}
+function init() {
+  const { root, manifest, manifestPath, moduleName } = packageRoot();
+  const rustPath = import_node_path.default.join(root, rustDirectory);
+  if (import_node_fs.default.existsSync(rustPath)) {
+    throw new Error("The rust/ directory already exists; no files were changed.");
+  }
+  const scripts = manifest.scripts || {};
+  if (scripts["rust:test"] || scripts["rust:generate"]) {
+    throw new Error("package.json already defines a rust:test or rust:generate script; no files were changed.");
+  }
+  const projectFiles = {
+    cppHeader: import_node_path.default.join(root, "cpp", `${moduleName}Impl.h`),
+    cppSource: import_node_path.default.join(root, "cpp", `${moduleName}Impl.cpp`),
+    nativeSpec: import_node_path.default.join(root, "src", `Native${moduleName}.ts`),
+    libraryIndex: import_node_path.default.join(root, "src", "index.tsx"),
+    androidCmake: import_node_path.default.join(root, "android", "CMakeLists.txt")
+  };
+  const podspecs = import_node_fs.default.readdirSync(root).filter((fileName) => fileName.endsWith(".podspec"));
+  if (podspecs.length !== 1) throw new Error("Expected exactly one CocoaPods spec file. No files were changed.");
+  projectFiles.podspec = import_node_path.default.join(root, podspecs[0]);
+  if (Object.values(projectFiles).some((filePath) => !import_node_fs.default.existsSync(filePath))) {
+    throw new Error("Expected C++ library template files were not found. No files were changed.");
+  }
+  const contents = Object.fromEntries(Object.entries(projectFiles).map(([key, filePath]) => [
+    key,
+    import_node_fs.default.readFileSync(filePath, "utf8")
+  ]));
+  const targetMatch = contents.androidCmake.match(/add_library\(\s*([a-zA-Z0-9_-]+)\s+STATIC/);
+  if (!targetMatch || !contents.cppHeader.includes("#pragma once")) {
+    throw new Error("The native files do not match the supported C++ TurboModule template. No files were changed.");
+  }
+  const methods = (0, import_codegen.parseSpec)(contents.nativeSpec, import_node_path.default.relative(root, projectFiles.nativeSpec));
+  const crateName = (manifest.name || "react-native-rust").replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9_]+/g, "_");
+  const crateDirName = /^\d/.test(crateName) ? `rust_${crateName.toLowerCase()}` : crateName.toLowerCase();
+  const targetName = targetMatch[1];
+  const linkMatch = contents.androidCmake.match(/target_link_libraries\(\s*([a-zA-Z0-9_-]+)([\s\S]*?)\n\)/);
+  if (!linkMatch || linkMatch[1] !== targetName) {
+    throw new Error("Could not locate the C++ target link block in android/CMakeLists.txt.");
+  }
+  const androidLink = `${linkMatch[0].slice(0, -2)}
+    rust_core
+    log
+    dl
+    m
+)`;
+  const rustImport = `add_library(rust_core STATIC IMPORTED)
+set_target_properties(rust_core PROPERTIES
+    IMPORTED_LOCATION "\${CMAKE_CURRENT_LIST_DIR}/../rust/build/android/\${ANDROID_ABI}/lib${crateDirName}.a"
+)
+
+`;
+  const androidCmake = contents.androidCmake.replace(linkMatch[0], androidLink).replace(/add_library\(/, `${rustImport}add_library(`);
+  const podspecSource = contents.podspec.match(/^\s*s\.source_files\s*=.*$/m);
+  if (!podspecSource) throw new Error("Could not locate source_files in the CocoaPods spec.");
+  const podspec = contents.podspec.replace(
+    podspecSource[0],
+    `${podspecSource[0]}
+  s.vendored_frameworks = "rust/build/ios/${moduleName}Rust.xcframework"`
+  );
+  const rustFiles = {
+    "Cargo.toml": `[package]
+name = "${crateDirName}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["staticlib", "cdylib"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
+js-sys = "0.3"
+
+[build-dependencies]
+cbindgen = "0.26"
+`,
+    "build.rs": `use std::path::PathBuf;
+
+fn main() {
+    let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let output = PathBuf::from(&crate_dir).join("include/rust_api.h");
+    std::fs::create_dir_all(output.parent().unwrap()).unwrap();
+    cbindgen::generate(&crate_dir)
+        .expect("failed to generate the Rust C header")
+        .write_to_file(output);
+}
+`,
+    "cbindgen.toml": `language = "C++"
+`,
+    "src/ffi.rs": (0, import_codegen.renderRustFfiModule)(),
+    "README.md": `# Rust core
+
+Rust handlers are generated from the TurboModule Spec interface in src/Native${moduleName}.ts. Edit the generated functions under rust/src/api/ and regenerate native glue with npx react-native-rust generate.
+
+Run cargo test --manifest-path rust/Cargo.toml for Rust tests. Build iOS and Android artifacts with npx react-native-rust build ios and npx react-native-rust build android before native app builds. Build the react-native-web WebAssembly package with npx react-native-rust build web (requires wasm-pack and the wasm32-unknown-unknown Rust target).
+`
+  };
+  const updates = (0, import_codegen.renderProjectBindings)(root, moduleName, methods, true, crateDirName);
+  updates.set(projectFiles.androidCmake, androidCmake);
+  updates.set(projectFiles.podspec, podspec);
+  const cliManifest = 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(root, cliRoot).split(import_node_path.default.sep).join("/") || "."}`;
+  const updatedManifest = {
+    ...manifest,
+    devDependencies: {
+      ...manifest.devDependencies,
+      [cliManifest.name]: manifest.devDependencies?.[cliManifest.name] || cliDependency
+    },
+    scripts: {
+      ...scripts,
+      "rust:test": "cargo test --manifest-path rust/Cargo.toml",
+      "rust:generate": "react-native-rust generate",
+      "rust:build:ios": "react-native-rust build ios",
+      "rust:build:android": "react-native-rust build android",
+      "rust:build:web": "react-native-rust build web"
+    }
+  };
+  const packageFiles = Array.isArray(updatedManifest.files) ? [...updatedManifest.files] : [];
+  for (const filePath of ["rust/", "rust/build/", "rust/include/"]) {
+    if (!packageFiles.includes(filePath)) packageFiles.push(filePath);
+  }
+  updatedManifest.files = packageFiles;
+  updates.set(manifestPath, `${JSON.stringify(updatedManifest, null, 2)}
+`);
+  const gitignorePath = import_node_path.default.join(root, ".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" : "";
+    updates.set(gitignorePath, `${gitignore}${separator}${ignoredRustOutputs.join("\n")}
+`);
+  }
+  for (const [relativePath, fileContents] of Object.entries(rustFiles)) {
+    const outputPath = import_node_path.default.join(rustPath, relativePath);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputPath), { recursive: true });
+    import_node_fs.default.writeFileSync(outputPath, fileContents);
+  }
+  for (const [filePath, fileContents] of updates) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(filePath), { recursive: true });
+    import_node_fs.default.writeFileSync(filePath, fileContents);
+  }
+  console.log(`Generated ${methods.length} Rust handler(s) and native bindings from Spec.`);
+  console.log("Run `npx react-native-rust build ios` or `npx react-native-rust build android` before building the React Native app.");
+}
+function generate() {
+  const { root, moduleName } = packageRoot();
+  const rustPath = import_node_path.default.join(root, rustDirectory);
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(rustPath, "Cargo.toml"))) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  const nativeSpecPath = import_node_path.default.join(root, "src", `Native${moduleName}.ts`);
+  const methods = (0, import_codegen.parseSpec)(import_node_fs.default.readFileSync(nativeSpecPath, "utf8"), import_node_path.default.relative(root, nativeSpecPath));
+  const updates = (0, import_codegen.renderProjectBindings)(root, moduleName, methods, false, readCrateName(rustPath));
+  for (const [filePath, fileContents] of updates) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(filePath), { recursive: true });
+    import_node_fs.default.writeFileSync(filePath, fileContents);
+  }
+  console.log(`Regenerated Rust, C++, and TypeScript glue for ${methods.length} Spec method(s).`);
+}
+function doctor(target) {
+  const { root } = packageRoot();
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(root, rustDirectory, "Cargo.toml"))) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  let failed = false;
+  for (const command of ["rustc", "cargo"]) {
+    const result = run(command, ["--version"]);
+    console.log(`${result.ok ? "OK" : "MISSING"} ${command}${result.output ? `: ${result.output}` : ""}`);
+    failed ||= !result.ok;
+  }
+  if (target === "ios") {
+    const xcode = run("xcodebuild", ["-version"]);
+    const lipo = run("lipo", ["-version"]);
+    console.log(`${xcode.ok ? "OK" : "MISSING"} Xcode`);
+    console.log(`${lipo.ok ? "OK" : "MISSING"} lipo`);
+    failed ||= process.platform !== "darwin" || !xcode.ok || !lipo.ok;
+  }
+  if (target === "android") {
+    const ndkPath = process.env.ANDROID_NDK_HOME || process.env.ANDROID_NDK_ROOT;
+    const cargoNdk = run("cargo", ["ndk", "--version"]);
+    console.log(`${ndkPath ? "OK" : "CHECK"} Android NDK path (cargo-ndk can auto-detect Android Studio installs)`);
+    console.log(`${cargoNdk.ok ? "OK" : "MISSING"} cargo-ndk`);
+    failed ||= !cargoNdk.ok;
+  }
+  if (target === "web") {
+    const wasmPack = run("wasm-pack", ["--version"]);
+    const installedTargets = run("rustup", ["target", "list", "--installed"]);
+    const hasWasmTarget = installedTargets.ok && (installedTargets.output || "").includes("wasm32-unknown-unknown");
+    console.log(`${wasmPack.ok ? "OK" : "MISSING"} wasm-pack`);
+    console.log(`${hasWasmTarget ? "OK" : "MISSING"} wasm32-unknown-unknown Rust target (rustup target add wasm32-unknown-unknown)`);
+    failed ||= !wasmPack.ok || !hasWasmTarget;
+  }
+  if (failed) process.exitCode = 1;
+}
+function build(platform) {
+  const { root, manifest, moduleName } = packageRoot();
+  const rustRoot = import_node_path.default.join(root, rustDirectory);
+  const manifestPath = import_node_path.default.join(rustRoot, "Cargo.toml");
+  if (!import_node_fs.default.existsSync(manifestPath)) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  const crateName = readCrateName(rustRoot);
+  const releasePath = (target) => import_node_path.default.join(rustRoot, "target", target, "release", `lib${crateName}.a`);
+  if (platform === "ios") {
+    for (const target of iosTargets) {
+      const result = run("cargo", ["build", "--release", "--target", target, "--manifest-path", manifestPath], { inherit: true });
+      if (!result.ok) throw new Error(`iOS build failed for ${target}: ${result.message}`);
+    }
+    const buildPath = import_node_path.default.join(rustRoot, "build", "ios");
+    import_node_fs.default.mkdirSync(buildPath, { recursive: true });
+    const simulatorDirectory = import_node_path.default.join(buildPath, "simulator");
+    import_node_fs.default.mkdirSync(simulatorDirectory, { recursive: true });
+    const simulatorArchive = import_node_path.default.join(simulatorDirectory, `lib${crateName}.a`);
+    const lipo = run("lipo", [
+      "-create",
+      releasePath("aarch64-apple-ios-sim"),
+      releasePath("x86_64-apple-ios"),
+      "-output",
+      simulatorArchive
+    ], { inherit: true });
+    if (!lipo.ok) throw new Error(`Could not combine iOS simulator archives: ${lipo.message}`);
+    const frameworkPath = import_node_path.default.join(buildPath, `${moduleName}Rust.xcframework`);
+    import_node_fs.default.rmSync(frameworkPath, { recursive: true, force: true });
+    const xcframework = run("xcodebuild", [
+      "-create-xcframework",
+      "-library",
+      releasePath("aarch64-apple-ios"),
+      "-headers",
+      import_node_path.default.join(rustRoot, "include"),
+      "-library",
+      simulatorArchive,
+      "-headers",
+      import_node_path.default.join(rustRoot, "include"),
+      "-output",
+      frameworkPath
+    ], { inherit: true });
+    if (!xcframework.ok) throw new Error(`Could not create the iOS XCFramework: ${xcframework.message}`);
+    console.log(`Built ${import_node_path.default.relative(root, frameworkPath)} for ${manifest.name}.`);
+    return;
+  }
+  if (platform === "android") {
+    const result = run("cargo", [
+      "ndk",
+      "-t",
+      "arm64-v8a",
+      "-t",
+      "armeabi-v7a",
+      "-t",
+      "x86",
+      "-t",
+      "x86_64",
+      "build",
+      "--release"
+    ], { inherit: true, cwd: rustRoot });
+    if (!result.ok) throw new Error(`Android build failed: ${result.message}`);
+    for (const [abi, target] of androidTargets) {
+      const outputDirectory = import_node_path.default.join(rustRoot, "build", "android", abi);
+      import_node_fs.default.mkdirSync(outputDirectory, { recursive: true });
+      import_node_fs.default.copyFileSync(releasePath(target), import_node_path.default.join(outputDirectory, `lib${crateName}.a`));
+    }
+    console.log(`Built Android static archives for ${manifest.name}.`);
+    return;
+  }
+  if (platform === "web") {
+    const result = run("wasm-pack", ["build", "--target", "web", "--out-dir", import_node_path.default.join("build", "web", "pkg")], { inherit: true, cwd: rustRoot });
+    if (!result.ok) throw new Error(`Web build failed: ${result.message}`);
+    console.log(`Built rust/build/web/pkg for ${manifest.name}.`);
+    return;
+  }
+  throw new Error("Choose a build target: ios, android, or web.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  doctor,
+  generate,
+  init,
+  packageRoot,
+  readJson,
+  run
+});