@rejaul/react-native-rust 1.0.1

package/bin/codegen/renderers.js

@@ -0,0 +1,357 @@
+function renderRustFfiModule() {
+  return `use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::ffi::c_void;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::slice;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct RustSlice {
+    pub data: *const u8,
+    pub len: usize,
+}
+
+#[repr(C)]
+pub struct RustBuffer {
+    pub data: *mut u8,
+    pub len: usize,
+    pub capacity: usize,
+    pub is_error: bool,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct RustCallback {
+    pub context: *mut c_void,
+    pub invoke: unsafe extern "C" fn(*mut c_void, RustSlice),
+}
+
+pub unsafe fn decode_json<T: DeserializeOwned>(value: RustSlice) -> Result<T, String> {
+    let bytes = if value.len == 0 {
+        &[]
+    } else {
+        if value.data.is_null() {
+            return Err("Received a null JSON buffer".to_string());
+        }
+        slice::from_raw_parts(value.data, value.len)
+    };
+    serde_json::from_slice(bytes).map_err(|error| format!("Invalid JSON input: {error}"))
+}
+
+fn into_buffer(mut bytes: Vec<u8>, is_error: bool) -> RustBuffer {
+    let buffer = RustBuffer {
+        data: bytes.as_mut_ptr(),
+        len: bytes.len(),
+        capacity: bytes.capacity(),
+        is_error,
+    };
+    std::mem::forget(bytes);
+    buffer
+}
+
+pub fn encode_result<T: Serialize>(result: Result<T, String>) -> RustBuffer {
+    match result {
+        Ok(value) => match serde_json::to_vec(&value) {
+            Ok(bytes) => into_buffer(bytes, false),
+            Err(error) => into_buffer(error.to_string().into_bytes(), true),
+        },
+        Err(error) => into_buffer(error.into_bytes(), true),
+    }
+}
+
+pub fn catch_json<T: Serialize>(call: impl FnOnce() -> Result<T, String>) -> RustBuffer {
+    let result = catch_unwind(AssertUnwindSafe(call))
+        .unwrap_or_else(|_| Err("Rust handler panicked".to_string()));
+    encode_result(result)
+}
+
+#[no_mangle]
+pub extern "C" fn rnrs_buffer_free(buffer: RustBuffer) {
+    if !buffer.data.is_null() {
+        unsafe {
+            drop(Vec::from_raw_parts(buffer.data, buffer.len, buffer.capacity));
+        }
+    }
+}
+`;
+}
+
+function renderRustExports(methods) {
+  const lines = ['mod api;', 'mod ffi;', 'pub use ffi::{rnrs_buffer_free, RustBuffer, RustCallback, RustSlice};', ''];
+  for (const method of methods) {
+    const abiParams = method.params.map((param) => `${param.name}: ffi::${param.kind === 'callback' ? 'RustCallback' : 'RustSlice'}`).join(', ');
+    lines.push('#[no_mangle]');
+    lines.push(`pub extern "C" fn ${method.symbol}(${abiParams}) -> ffi::RustBuffer {`);
+    lines.push('    ffi::catch_json(|| {');
+
+    for (const param of method.params) {
+      if (param.kind !== 'callback') {
+        lines.push(`        let ${param.name}: ${param.rust} = unsafe { ffi::decode_json(${param.name}) }?;`);
+        continue;
+      }
+      const callbackParams = param.params.map((callbackParam) => `${callbackParam.name}: ${callbackParam.rust}`).join(', ');
+      const callbackValues = param.params.map((callbackParam) => callbackParam.name).join(', ');
+      const payload = callbackValues.length === 0 ? 'Vec::<u8>::new()' : `serde_json::to_vec(&(${callbackValues}${param.params.length === 1 ? ',' : ''})).unwrap_or_default()`;
+      lines.push(`        let mut ${param.name}_callback = |${callbackParams}| {`);
+      lines.push(`            let payload = ${payload};`);
+      lines.push(`            let slice = ffi::RustSlice { data: payload.as_ptr(), len: payload.len() };`);
+      lines.push(`            unsafe { (${param.name}.invoke)(${param.name}.context, slice); }`);
+      lines.push('        };');
+    }
+
+    const callArgs = method.params.map((param) => param.kind === 'callback' ? `&mut ${param.name}_callback` : param.name).join(', ');
+    const call = `api::${method.rustName}::${method.rustName}(${callArgs})`;
+    if (method.returnType.promise) {
+      lines.push(`        ${call}`);
+    } else if (method.returnType.kind === 'void') {
+      lines.push(`        ${call};`);
+      lines.push('        Ok(())');
+    } else {
+      lines.push(`        Ok(${call})`);
+    }
+    lines.push('    })', '}', '');
+  }
+  return lines.join('\n');
+}
+
+function renderRustHandler(method) {
+  const params = method.params.map((param) => {
+    if (param.kind === 'callback') {
+      const callbackTypes = param.params.map((callbackParam) => callbackParam.rust).join(', ');
+      return `${param.name}: &mut dyn FnMut(${callbackTypes})`;
+    }
+    return `${param.name}: ${param.rust}`;
+  }).join(', ');
+  const returnType = method.returnType.promise ? `Result<${method.returnType.rust}, String>` : method.returnType.rust;
+  const lines = [`// TODO: Replace the generated placeholder with the method implementation.`, `pub fn ${method.rustName}(${params}) -> ${returnType} {`];
+  for (const param of method.params) {
+    if (param.kind === 'callback') lines.push(`    let _ = &mut ${param.name};`);
+    else lines.push(`    let _ = ${param.name};`);
+  }
+  if (method.returnType.promise) lines.push(`    Ok(${method.returnType.defaultValue})`);
+  else if (method.returnType.defaultValue !== null) lines.push(`    ${method.returnType.defaultValue}`);
+  lines.push('}', '');
+  return lines.join('\n');
+}
+
+function renderRustModuleList(methods) {
+  return `${methods.map((method) => `pub(crate) mod ${method.rustName};`).join('\n')}\n`;
+}
+
+function renderCppHelpers() {
+  return `#include <exception>
+#include <string>
+#include <thread>
+#include <vector>
+
+struct RustBufferOwner {
+  RustBuffer value;
+  ~RustBufferOwner() { rnrs_buffer_free(value); }
+};
+
+static std::string rnrsStringify(jsi::Runtime& runtime, const jsi::Value& value) {
+  auto json = runtime.global().getPropertyAsObject(runtime, "JSON");
+  auto stringify = json.getPropertyAsFunction(runtime, "stringify");
+  auto result = stringify.call(runtime, value);
+  if (!result.isString()) throw jsi::JSError(runtime, "Value cannot be serialized as JSON");
+  return result.getString(runtime).utf8(runtime);
+}
+
+static jsi::Value rnrsParseJson(jsi::Runtime& runtime, const uint8_t* data, size_t length) {
+  auto json = runtime.global().getPropertyAsObject(runtime, "JSON");
+  auto parse = json.getPropertyAsFunction(runtime, "parse");
+  auto text = jsi::String::createFromUtf8(runtime, data, length);
+  return parse.call(runtime, std::move(text));
+}
+
+static jsi::Value rnrsFromRust(jsi::Runtime& runtime, RustBuffer buffer) {
+  RustBufferOwner owner{buffer};
+  if (buffer.is_error) {
+    std::string message(reinterpret_cast<const char*>(buffer.data), buffer.len);
+    throw jsi::JSError(runtime, message);
+  }
+  return rnrsParseJson(runtime, buffer.data, buffer.len);
+}
+
+struct RustCallbackContext {
+  jsi::Runtime* runtime;
+  jsi::Function* function;
+  std::exception_ptr exception;
+};
+
+extern "C" void rnrsDispatchCallback(void* context, RustSlice payload) noexcept {
+  auto* callback = static_cast<RustCallbackContext*>(context);
+  try {
+    auto value = rnrsParseJson(*callback->runtime, payload.data, payload.len);
+    auto array = value.asObject(*callback->runtime).asArray(*callback->runtime);
+    std::vector<jsi::Value> arguments;
+    arguments.reserve(array.size(*callback->runtime));
+    for (size_t index = 0; index < array.size(*callback->runtime); index++) {
+      arguments.push_back(array.getValueAtIndex(*callback->runtime, index));
+    }
+    callback->function->call(*callback->runtime, static_cast<const jsi::Value*>(arguments.data()), arguments.size());
+  } catch (...) {
+    callback->exception = std::current_exception();
+  }
+}
+
+template <typename Work>
+static jsi::Value rnrsMakePromise(
+    jsi::Runtime& runtime,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    Work work) {
+  auto promiseConstructor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+  auto executor = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "reactNativeRustExecutor"),
+      2,
+      [jsInvoker = std::move(jsInvoker), work = std::move(work)](
+          jsi::Runtime& executorRuntime,
+          const jsi::Value&,
+          const jsi::Value* arguments,
+          size_t count) mutable -> jsi::Value {
+        if (count != 2) throw jsi::JSError(executorRuntime, "Promise executor requires resolve and reject");
+        auto resolve = std::make_shared<jsi::Function>(arguments[0].asObject(executorRuntime).asFunction(executorRuntime));
+        auto reject = std::make_shared<jsi::Function>(arguments[1].asObject(executorRuntime).asFunction(executorRuntime));
+        std::thread([
+            jsInvoker,
+            work = std::move(work),
+            resolve,
+            reject]() mutable {
+          RustBuffer result = work();
+          jsInvoker->invokeAsync([
+              result,
+              resolve,
+              reject](jsi::Runtime& callbackRuntime) mutable {
+            if (result.is_error) {
+              std::string message(reinterpret_cast<const char*>(result.data), result.len);
+              rnrs_buffer_free(result);
+              reject->call(callbackRuntime, jsi::String::createFromUtf8(callbackRuntime, message));
+              return;
+            }
+            try {
+              auto value = rnrsFromRust(callbackRuntime, result);
+              resolve->call(callbackRuntime, std::move(value));
+            } catch (...) {
+              reject->call(callbackRuntime, jsi::String::createFromUtf8(callbackRuntime, "Could not decode Rust Promise result"));
+            }
+          });
+        }).detach();
+        return jsi::Value::undefined();
+      });
+  return promiseConstructor.callAsConstructor(runtime, std::move(executor));
+}`;
+}
+
+function renderCppMethods(methods, moduleName) {
+  const cppArgName = (index) => `rnrsArg${index}`;
+  const cppType = (method) => method.returnType.promise ? 'jsi::Value' : method.returnType.cpp;
+  const declarations = methods.map((method) => {
+    const params = method.params.map((param, index) => `${param.cpp} ${cppArgName(index)}`);
+    return `  ${cppType(method)} ${method.name}(jsi::Runtime& rnrsRuntime${params.length ? `, ${params.join(', ')}` : ''});`;
+  });
+
+  const definitions = methods.map((method) => {
+    const params = method.params.map((param, index) => `${param.cpp} ${cppArgName(index)}`);
+    const signature = `${cppType(method)} ${moduleName}Impl::${method.name}(\n  jsi::Runtime& rnrsRuntime${params.length ? `,\n  ${params.join(',\n  ')}` : ''}\n)`;
+    const jsonArgs = [];
+    const callbackArgs = [];
+    const setup = [];
+    method.params.forEach((param, index) => {
+      const name = cppArgName(index);
+      if (param.kind === 'callback') {
+        const context = `rnrsCallbackContext${index}`;
+        const bridge = `rnrsCallbackBridge${index}`;
+        setup.push(`  RustCallbackContext ${context}{&rnrsRuntime, &${name}, nullptr};`);
+        setup.push(`  RustCallback ${bridge}{&${context}, &rnrsDispatchCallback};`);
+        callbackArgs.push({ name, context, bridge });
+        return;
+      }
+      const json = `rnrsJson${index}`;
+      const slice = `rnrsSlice${index}`;
+      setup.push(`  auto ${json} = rnrsStringify(rnrsRuntime, jsi::Value(rnrsRuntime, std::move(${name})));`);
+      setup.push(`  RustSlice ${slice}{reinterpret_cast<const uint8_t*>(${json}.data()), ${json}.size()};`);
+      jsonArgs.push({ json, slice });
+    });
+
+    const ffiArgs = method.params.map((param, index) => (
+      param.kind === 'callback' ? `rnrsCallbackBridge${index}` : `rnrsSlice${index}`
+    ));
+    if (method.returnType.promise) {
+      const captures = jsonArgs.map(({ json }) => `${json} = std::move(${json})`);
+      const workerLines = [];
+      method.params.forEach((param, index) => {
+        if (param.kind !== 'callback') {
+          const json = `rnrsJson${index}`;
+          workerLines.push(`    RustSlice rnrsSlice${index}{reinterpret_cast<const uint8_t*>(${json}.data()), ${json}.size()};`);
+        }
+      });
+      workerLines.push(`    return ${method.symbol}(${ffiArgs.join(', ')});`);
+      return [signature + ' {', ...setup, `  return rnrsMakePromise(rnrsRuntime, jsInvoker_, [${captures.join(', ')}]() mutable {`, ...workerLines, '  });', '}'].join('\n');
+    }
+
+    const call = `auto rnrsResult = ${method.symbol}(${ffiArgs.join(', ')});`;
+    const callbackErrorChecks = callbackArgs.map(({ context }) => `  if (${context}.exception) { rnrs_buffer_free(rnrsResult); std::rethrow_exception(${context}.exception); }`);
+    const decoded = 'auto rnrsValue = rnrsFromRust(rnrsRuntime, rnrsResult);';
+    let resultLine;
+    switch (method.returnType.kind) {
+      case 'void': resultLine = '  (void)rnrsValue;\n  return;'; break;
+      case 'number': resultLine = '  return rnrsValue.asNumber();'; break;
+      case 'boolean': resultLine = '  return rnrsValue.asBool();'; break;
+      case 'string': resultLine = '  return rnrsValue.asString(rnrsRuntime);'; break;
+      case 'array': resultLine = '  return rnrsValue.asObject(rnrsRuntime).asArray(rnrsRuntime);'; break;
+      case 'json':
+        if (method.returnType.cpp === 'jsi::String') resultLine = '  return rnrsValue.asString(rnrsRuntime);';
+        else if (method.returnType.cpp === 'jsi::Array') resultLine = '  return rnrsValue.asObject(rnrsRuntime).asArray(rnrsRuntime);';
+        else resultLine = '  return rnrsValue.asObject(rnrsRuntime);';
+        break;
+      default: throw new Error(`No C++ return conversion for ${method.returnType.kind}.`);
+    }
+    return [signature + ' {', ...setup, `  ${call}`, ...callbackErrorChecks, `  ${decoded}`, resultLine, '}'].join('\n');
+  });
+  return {
+    header: declarations.join('\n'),
+    source: `${renderCppHelpers()}\n\n${definitions.join('\n\n')}`,
+  };
+}
+
+function renderWrappers(methods, moduleName) {
+  const nativeLines = [`import ${moduleName} from './Native${moduleName}';`, ''];
+  const fallbackLines = [];
+  const usesUnsafeObject = methods.some((method) => (
+    method.returnType.typescript.includes('UnsafeObject')
+    || method.params.some((param) => param.typescript.includes('UnsafeObject'))
+  ));
+  if (usesUnsafeObject) {
+    const codegenTypesDeclaration = 'declare namespace CodegenTypes { type UnsafeObject = object; }';
+    nativeLines.unshift(codegenTypesDeclaration);
+    fallbackLines.push(codegenTypesDeclaration, '');
+  }
+  for (const method of methods) {
+    const tsParams = method.params.map((param) => `${param.name}: ${param.typescript}`).join(', ');
+    const args = method.params.map((param) => param.name).join(', ');
+    const nativeCall = `${moduleName}.${method.name}(${args})`;
+    nativeLines.push(`export function ${method.name}(${tsParams}): ${method.returnType.typescript} {`);
+    nativeLines.push(method.returnType.typescript === 'void' ? `  ${nativeCall};` : `  return ${nativeCall};`);
+    nativeLines.push('}', '');
+
+    const fallbackParams = method.params.map((param) => `_${param.name}: ${param.typescript}`).join(', ');
+    fallbackLines.push(`export function ${method.name}(${fallbackParams}): ${method.returnType.typescript} {`);
+    fallbackLines.push("  throw new Error('This method is only supported on native platforms.');", '}', '');
+  }
+  return {
+    native: nativeLines.join('\n'),
+    fallback: fallbackLines.join('\n'),
+  };
+}
+
+module.exports = {
+  renderRustFfiModule,
+  renderRustExports,
+  renderRustHandler,
+  renderRustModuleList,
+  renderCppHelpers,
+  renderCppMethods,
+  renderWrappers,
+};

package/bin/codegen/spec.js

@@ -0,0 +1,156 @@
+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

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