@rejaul/react-native-rust 1.0.1 → 1.1.1

package/dist/react-native-rust.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+"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 __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 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");
+var import_app = require("./app");
+function printHelp() {
+  console.log(`react-native-rust - Rust helper for React Native C++ TurboModule libraries
+
+Usage:
+  react-native-rust create <name>  Create a React Native library and initialize Rust support
+  react-native-rust init             Add Rust support and generate functions from the Spec interface
+  react-native-rust init --app       Add app-local Rust support to a React Native app
+  react-native-rust generate         Regenerate Rust, C++, and TypeScript glue from Spec
+  react-native-rust doctor [target]  Check Rust and optional ios/android/web prerequisites
+  react-native-rust build ios        Build an iOS XCFramework
+  react-native-rust build android    Build Android static archives for supported ABIs
+  react-native-rust build web        Build a WebAssembly package for react-native-web
+  react-native-rust --help           Show this help
+
+Create a library first with the C++ module template from:
+  npx create-react-native-library@latest`);
+}
+function createProject(projectName) {
+  if (!projectName || projectName.startsWith("-") || import_node_path.default.basename(projectName) !== projectName) {
+    throw new Error("Usage: react-native-rust create <library-name>");
+  }
+  const projectPath = import_node_path.default.resolve(process.cwd(), projectName);
+  if (import_node_fs.default.existsSync(projectPath)) {
+    throw new Error(`The target directory already exists: ${projectPath}`);
+  }
+  console.log("In the scaffolder prompts, select a TurboModule library using C++.");
+  const scaffold = (0, import_node_child_process.spawnSync)("npx", ["--yes", "create-react-native-library@latest", projectName], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    encoding: "utf8"
+  });
+  if (scaffold.error) throw new Error(`React Native library creation failed: ${scaffold.error.message}`);
+  if (scaffold.status !== 0) throw new Error("React Native library creation failed.");
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(projectPath, "package.json"))) {
+    throw new Error(`The scaffolder did not create ${projectPath}.`);
+  }
+  const initialized = (0, import_node_child_process.spawnSync)(process.execPath, [__filename, "init"], {
+    cwd: projectPath,
+    stdio: "inherit",
+    encoding: "utf8"
+  });
+  if (initialized.error) {
+    throw new Error(`Rust initialization failed in ${projectPath}: ${initialized.error.message}`);
+  }
+  if (initialized.status !== 0) {
+    throw new Error(`Rust initialization failed in ${projectPath}.`);
+  }
+  console.log(`Created ${projectName}. Next run \`cd ${projectName} && yarn install\`.`);
+}
+function main(args) {
+  const [command, option] = args;
+  if (!command || command === "--help" || command === "-h") return printHelp();
+  if (command === "create") return createProject(option);
+  if (command === "init") {
+    if (option === "--app") return (0, import_app.initApp)();
+    if (option) throw new Error("Use `react-native-rust init --app` for an app, or run `react-native-rust init` from a C++ TurboModule library.");
+    return (0, import_react_native_rust_lib.init)();
+  }
+  const appRoot = process.cwd();
+  const appModule = (0, import_app.appModuleRoot)(appRoot);
+  if (command === "generate") {
+    if (!appModule) return (0, import_react_native_rust_lib.generate)();
+    return (0, import_app.inDirectory)(appModule, () => {
+      (0, import_react_native_rust_lib.generate)();
+      (0, import_app.runCodegen)(appRoot, appModule);
+    });
+  }
+  if (command === "doctor") {
+    if (option && option !== "ios" && option !== "android" && option !== "web") {
+      throw new Error("Choose a doctor target: ios, android, or web.");
+    }
+    const target = option;
+    return appModule ? (0, import_app.inDirectory)(appModule, () => (0, import_react_native_rust_lib.doctor)(target)) : (0, import_react_native_rust_lib.doctor)(target);
+  }
+  if (command === "build") {
+    if (!appModule) return (0, import_react_native_rust_lib.build)(option);
+    (0, import_app.runCodegen)(appRoot, appModule);
+    return (0, import_app.inDirectory)(appModule, () => (0, import_react_native_rust_lib.build)(option));
+  }
+  throw new Error(`Unknown command: ${command}. Run react-native-rust --help for usage.`);
+}
+try {
+  main(process.argv.slice(2));
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+}

package/dist/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/package.json

@@ -1,28 +1,45 @@
 {
   "name": "@rejaul/react-native-rust",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Generate Rust and native bindings from React Native TurboModule TypeScript interfaces.",
   "engines": {
     "node": ">=18"
   },
   "files": [
-    "bin/",
+    "dist/",
     "README.md",
     "LICENSE",
     "CONTRIBUTING.md",
     "CODE_OF_CONDUCT.md"
   ],
   "bin": {
-    "react-native-rust": "./bin/react-native-rust.js"
+    "react-native-rust": "./dist/react-native-rust.js"
   },
   "scripts": {
+    "build": "node scripts/build.js",
+    "typecheck": "tsc",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "pretest": "npm run typecheck && npm run build",
     "test": "node --test"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/DeveloperRejaul/react-native-rust.git"
   },
-  "keywords": [],
+  "keywords": [
+    "react-native",
+    "rust",
+    "typescript",
+    "turbomodule",
+    "codegen",
+    "cli",
+    "ios",
+    "android",
+    "jsi",
+    "cpp",
+    "ffi"
+  ],
   "author": "",
   "license": "ISC",
   "bugs": {
@@ -31,5 +48,12 @@
   "homepage": "https://github.com/DeveloperRejaul/react-native-rust#readme",
   "dependencies": {
     "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^20.19.43",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.11.0",
+    "typescript-eslint": "^8.71.0"
   }
 }

package/bin/codegen/constants.js

@@ -1,39 +0,0 @@
-const ts = 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 = 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 = 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 = new Map([
-  [ts.SyntaxKind.NumberKeyword, { kind: 'number', typescript: 'number', rust: 'f64', cpp: 'double', defaultValue: '0.0' }],
-  [ts.SyntaxKind.BooleanKeyword, { kind: 'boolean', typescript: 'boolean', rust: 'bool', cpp: 'bool', defaultValue: 'false' }],
-  [ts.SyntaxKind.StringKeyword, { kind: 'json', typescript: 'string', rust: 'String', cpp: 'jsi::String', defaultValue: 'String::new()' }],
-  [ts.SyntaxKind.VoidKeyword, { kind: 'void', typescript: 'void', rust: '()', cpp: 'void', defaultValue: null }],
-]);
-
-module.exports = {
-  HEADER_START,
-  HEADER_END,
-  SOURCE_START,
-  SOURCE_END,
-  rustKeywords,
-  cppKeywords,
-  supportedTypes,
-  ts,
-};

package/bin/codegen/index.js

@@ -1,9 +0,0 @@
-const { parseSpec } = require('./spec');
-const { renderRustFfiModule } = require('./renderers');
-const { renderProjectBindings } = require('./project');
-
-module.exports = {
-  parseSpec,
-  renderRustFfiModule,
-  renderProjectBindings,
-};

package/bin/codegen/project.js

@@ -1,168 +0,0 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const {
-  HEADER_START,
-  HEADER_END,
-  SOURCE_START,
-  SOURCE_END,
-} = require('./constants');
-const { renderCppMethods, renderRustExports, renderRustHandler, renderRustModuleList, renderWrappers } = require('./renderers');
-
-function replaceMarkedRegion(source, startMarker, endMarker, generated) {
-  const start = source.indexOf(startMarker);
-  const end = source.indexOf(endMarker);
-  if (start < 0 || end < start) return null;
-  const block = `${startMarker}\n${generated}\n${endMarker}`;
-  return `${source.slice(0, start)}${block}${source.slice(end + endMarker.length)}`;
-}
-
-function replaceTemplateMethod(source, markerStart, markerEnd, generated, methodNeedle) {
-  const functionIndex = source.indexOf(methodNeedle);
-  if (functionIndex < 0) throw new Error(`Could not locate C++ template method "${methodNeedle}".`);
-  const lineStart = source.lastIndexOf('\n', functionIndex) + 1;
-  const bodyStart = source.indexOf('{', functionIndex);
-  if (bodyStart < 0) throw new Error(`Could not locate the body for C++ method "${methodNeedle}".`);
-  let depth = 0;
-  let bodyEnd = -1;
-  for (let index = bodyStart; index < source.length; index += 1) {
-    if (source[index] === '{') depth += 1;
-    if (source[index] === '}') {
-      depth -= 1;
-      if (depth === 0) {
-        bodyEnd = index + 1;
-        break;
-      }
-    }
-  }
-  if (bodyEnd < 0) throw new Error(`Could not find the end of C++ method "${methodNeedle}".`);
-  const block = `${markerStart}\n${generated}\n${markerEnd}`;
-  return `${source.slice(0, lineStart)}${block}${source.slice(bodyEnd)}`;
-}
-
-function hasDefaultMultiplyBody(source, moduleName) {
-  const methodIndex = source.indexOf(`${moduleName}Impl::multiply(`);
-  if (methodIndex < 0) return false;
-  const bodyStart = source.indexOf('{', methodIndex);
-  if (bodyStart < 0) return false;
-  let depth = 0;
-  for (let index = bodyStart; index < source.length; index += 1) {
-    if (source[index] === '{') depth += 1;
-    if (source[index] === '}') {
-      depth -= 1;
-      if (depth === 0) {
-        return source.slice(bodyStart + 1, index).replace(/\s+/g, '') === 'returna*b;';
-      }
-    }
-  }
-  return false;
-}
-
-function updateCppFile(source, markers, generated, templateMethod, methodNeedle, includeRustHeader = false) {
-  let updated = source;
-  if (includeRustHeader && !updated.includes('../rust/include/rust_api.h')) {
-    if (!updated.includes('#pragma once')) throw new Error('Unsupported C++ module header template.');
-    updated = updated.replace('#pragma once', '#pragma once\n\n#include "../rust/include/rust_api.h"');
-  }
-  const marked = replaceMarkedRegion(updated, markers[0], markers[1], generated);
-  if (marked !== null) return marked;
-  if (updated.includes(markers[0]) || updated.includes(markers[1])) {
-    throw new Error('Incomplete react-native-rust generated markers found in C++ source.');
-  }
-  if (!templateMethod) throw new Error('C++ generated markers are missing; refusing to overwrite the module.');
-  if (methodNeedle.endsWith(';')) {
-    const count = updated.split(methodNeedle).length - 1;
-    if (count !== 1) throw new Error('Could not uniquely locate the C++ template method declaration.');
-    return updated.replace(methodNeedle, `${markers[0]}\n${generated}\n${markers[1]}`);
-  }
-  return replaceTemplateMethod(updated, markers[0], markers[1], generated, methodNeedle);
-}
-
-function normalizeSignature(text) {
-  return text.replace(/\s+/g, '');
-}
-
-function validateExistingHandler(filePath, method) {
-  const contents = fs.readFileSync(filePath, 'utf8');
-  const signaturePattern = new RegExp(`pub\\s+fn\\s+${method.rustName}\\s*\\(([^)]*)\\)\\s*->\\s*([^\\{]+)\\{`);
-  const match = contents.match(signaturePattern);
-  const args = method.params.map((param) => {
-    if (param.kind !== 'callback') return `${param.name}: ${param.rust}`;
-    const callbackTypes = param.params.map((callbackParam) => callbackParam.rust).join(', ');
-    return `${param.name}: &mut dyn FnMut(${callbackTypes})`;
-  }).join(', ');
-  const returnType = method.returnType.promise
-    ? `Result<${method.returnType.rust}, String>`
-    : method.returnType.rust;
-  const expected = `${method.rustName}(${args}) -> ${returnType}`;
-    const expectedSignature = `pub fn ${expected} {`;
-    if (normalizeSignature(contents).includes(normalizeSignature(expectedSignature))) return;
-  if (!match || normalizeSignature(match[0].replace(/^pub\s+fn\s+/, '').replace(/\{\s*$/, '')) !== normalizeSignature(expected)) {
-    throw new Error(`Rust handler ${path.relative(process.cwd(), filePath)} does not match the TypeScript Spec. Update its signature before regenerating.`);
-  }
-}
-
-function renderProjectBindings(root, moduleName, methods, initialize) {
-  const headerPath = path.join(root, 'cpp', `${moduleName}Impl.h`);
-  const sourcePath = path.join(root, 'cpp', `${moduleName}Impl.cpp`);
-  const header = fs.readFileSync(headerPath, 'utf8');
-  const source = fs.readFileSync(sourcePath, 'utf8');
-  if (initialize && !hasDefaultMultiplyBody(source, moduleName)) {
-    throw new Error('The C++ multiply demo was customized; move its logic into Rust before running init. No files were changed.');
-  }
-  const cpp = renderCppMethods(methods, moduleName);
-  const generatedIncludes = cpp.source.match(/^#include .+$/gm) || [];
-  const cppSource = cpp.source.replace(/^#include .+\n/gm, '');
-  const headerTemplateMethod = 'double multiply(jsi::Runtime& rt, double a, double b);';
-  const sourceTemplateMethod = `${moduleName}Impl::multiply(`;
-  const updatedHeader = updateCppFile(header, [HEADER_START, HEADER_END], cpp.header, initialize, headerTemplateMethod, true);
-  let updatedSource = updateCppFile(source, [SOURCE_START, SOURCE_END], cppSource, initialize, sourceTemplateMethod);
-  if (generatedIncludes.length > 0) {
-    const namespaceIndex = updatedSource.indexOf('\nnamespace facebook::react {');
-    if (namespaceIndex < 0) throw new Error('Could not locate the C++ namespace for generated includes.');
-    const missingIncludes = generatedIncludes.filter((include) => !updatedSource.includes(include));
-    if (missingIncludes.length > 0) {
-      const insertionPoint = namespaceIndex + 1;
-      updatedSource = `${updatedSource.slice(0, insertionPoint)}${missingIncludes.join('\n')}\n${updatedSource.slice(insertionPoint)}`;
-    }
-  }
-
-  const rustDirectory = path.join(root, 'rust', 'src');
-  const moduleList = renderRustModuleList(methods);
-  const updates = new Map([
-    [headerPath, updatedHeader],
-    [sourcePath, updatedSource],
-    [path.join(rustDirectory, 'lib.rs'), renderRustExports(methods)],
-    [path.join(rustDirectory, 'api', 'mod.rs'), moduleList],
-  ]);
-  for (const method of methods) {
-    const handlerPath = path.join(rustDirectory, 'api', `${method.rustName}.rs`);
-    if (fs.existsSync(handlerPath)) validateExistingHandler(handlerPath, method);
-    else updates.set(handlerPath, renderRustHandler(method));
-  }
-
-  const wrappers = renderWrappers(methods, moduleName);
-  const generatedModulePath = path.join(root, 'src', 'rust-generated');
-  updates.set(`${generatedModulePath}.tsx`, wrappers.fallback);
-  updates.set(`${generatedModulePath}.native.tsx`, wrappers.native);
-  const indexPath = path.join(root, 'src', 'index.tsx');
-  let index = fs.readFileSync(indexPath, 'utf8');
-  for (const method of methods) {
-    const oldExport = new RegExp(`^export\\s*\\{\\s*${method.name}\\s*\\}\\s*from\\s*['"]\\./${method.name}['"];?\\s*$`, 'm');
-    index = index.replace(oldExport, '');
-  }
-  if (!index.includes("export * from './rust-generated';")) {
-    index = `${index.trimEnd()}\nexport * from './rust-generated';\n`;
-  }
-  updates.set(indexPath, index);
-  return updates;
-}
-
-module.exports = {
-  replaceMarkedRegion,
-  replaceTemplateMethod,
-  hasDefaultMultiplyBody,
-  updateCppFile,
-  normalizeSignature,
-  validateExistingHandler,
-  renderProjectBindings,
-};

package/bin/codegen/spec.js

@@ -1,156 +0,0 @@
-const { supportedTypes, rustKeywords, cppKeywords, ts } = require('./constants');
-
-function typeInfo(typeNode, sourceFile, methodName, role) {
-  const info = supportedTypes.get(typeNode.kind);
-  if (info && !(role === 'parameter' && typeNode.kind === ts.SyntaxKind.VoidKeyword)) return info;
-
-  if (role === 'return' && 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.kind === 'callback' || 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 = ts.isTypeReferenceNode(typeNode) ? typeNode.typeName.getText(sourceFile) : '';
-  const objectType = typeNode.kind === 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 = ts.isArrayTypeNode(typeNode)
-    ? typeNode.elementType
-    : 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.kind === 'callback' || 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 (!ts.isFunctionTypeNode(typeNode) || typeNode.typeParameters?.length) {
-    throw new Error(`Unsupported callback signature in ${methodName}().`);
-  }
-  if (typeNode.type.kind !== 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 (!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 === 'callback' || 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) || rustKeywords.has(name) || cppKeywords.has(name)) {
-    throw new Error(`Unsupported identifier "${name}" in ${location}; use a non-keyword identifier.`);
-  }
-}
-
-function parseSpec(sourceText, fileName = 'NativeModule.ts') {
-  const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  if (sourceFile.parseDiagnostics.length > 0) {
-    const diagnostic = sourceFile.parseDiagnostics[0];
-    throw new Error(`Could not parse ${fileName}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')}`);
-  }
-
-  const spec = sourceFile.statements.find((statement) => (
-    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 = new Set();
-  const rustNames = new Set();
-  const methods = spec.members.map((member) => {
-    if (!ts.isMethodSignature(member)) {
-      throw new Error('Only method signatures are supported in the Spec interface.');
-    }
-    if (!member.name || !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 (!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 = 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;
-}
-
-module.exports = {
-  typeInfo,
-  callbackInfo,
-  toSnakeCase,
-  validateIdentifier,
-  parseSpec,
-};

package/bin/codegen.js

@@ -1 +0,0 @@
-module.exports = require('./codegen/index');