nitrogen 0.2.24 → 0.29.5

package/lib/views/kotlin/KotlinHybridViewManager.js

@@ -0,0 +1,229 @@
+import { createViewComponentShadowNodeFiles, getViewComponentNames, } from '../CppHybridViewComponent.js';
+import { createFileMetadataString, escapeCppName, } from '../../syntax/helpers.js';
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js';
+import { addJNINativeRegistration } from '../../syntax/kotlin/JNINativeRegistrations.js';
+import { indent } from '../../utils.js';
+export function createKotlinHybridViewManager(spec) {
+    const cppFiles = createViewComponentShadowNodeFiles(spec);
+    const javaSubNamespace = spec.config.getAndroidPackage('java/kotlin', 'views');
+    const javaNamespace = spec.config.getAndroidPackage('java/kotlin');
+    const cxxNamespace = spec.config.getCxxNamespace('c++', 'views');
+    const { JHybridTSpec, HybridTSpec } = getHybridObjectName(spec.name);
+    const { manager, stateClassName, component, propsClassName, descriptorClassName, } = getViewComponentNames(spec);
+    const stateUpdaterName = `${stateClassName}Updater`;
+    const autolinking = spec.config.getAutolinkedHybridObjects();
+    const viewImplementation = autolinking[spec.name]?.kotlin;
+    if (viewImplementation == null) {
+        throw new Error(`Cannot create Kotlin HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`);
+    }
+    const viewManagerCode = `
+${createFileMetadataString(`${manager}.kt`)}
+
+package ${javaSubNamespace}
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import ${javaNamespace}.*
+
+/**
+ * Represents the React Native \`ViewManager\` for the "${spec.name}" Nitro HybridView.
+ */
+class ${manager}: SimpleViewManager<View>() {
+  private val views = hashMapOf<View, ${viewImplementation}>()
+
+  override fun getName(): String {
+    return "${spec.name}"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View {
+    val hybridView = ${viewImplementation}(reactContext)
+    val view = hybridView.view
+    views[view] = hybridView
+    return view
+  }
+
+  override fun onDropViewInstance(view: View) {
+    super.onDropViewInstance(view)
+    views.remove(view)
+  }
+
+  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val hybridView = views[view] ?: throw Error("Couldn't find view $view in local views table!")
+
+    // 1. Update each prop individually
+    hybridView.beforeUpdate()
+    ${stateUpdaterName}.updateViewProps(hybridView, stateWrapper)
+    hybridView.afterUpdate()
+
+    // 2. Continue in base View props
+    return super.updateState(view, props, stateWrapper)
+  }
+}
+  `.trim();
+    const updaterKotlinCode = `
+${createFileMetadataString(`${stateUpdaterName}.kt`)}
+
+package ${javaSubNamespace}
+
+import com.facebook.react.uimanager.StateWrapper
+import ${javaNamespace}.*
+
+internal class ${stateUpdaterName} {
+  companion object {
+    /**
+     * Updates the props for [view] through C++.
+     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     */
+    @Suppress("KotlinJniMissingFunction")
+    @JvmStatic
+    external fun updateViewProps(view: ${HybridTSpec}, state: StateWrapper)
+  }
+}
+  `.trim();
+    const updaterJniDescriptor = spec.config.getAndroidPackage('c++/jni', 'views', stateUpdaterName);
+    const updaterJniHeaderCode = `
+${createFileMetadataString(`J${stateUpdaterName}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "${JHybridTSpec}.hpp"
+#include "views/${component}.hpp"
+
+namespace ${cxxNamespace} {
+
+using namespace facebook;
+
+class J${stateUpdaterName}: public jni::JavaClass<J${stateUpdaterName}> {
+public:
+  static constexpr auto kJavaDescriptor = "L${updaterJniDescriptor};";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<${JHybridTSpec}::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", J${stateUpdaterName}::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<${descriptorClassName}>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace ${cxxNamespace}
+  `.trim();
+    const propsUpdaterCalls = spec.properties.map((p) => {
+        const name = escapeCppName(p.name);
+        const setter = p.getSetterName('other');
+        return `
+if (props.${name}.isDirty) {
+  view->${setter}(props.${name}.value);
+  // TODO: Set isDirty = false
+}
+    `.trim();
+    });
+    const updaterJniCppCode = `
+${createFileMetadataString(`J${stateUpdaterName}.cpp`)}
+
+#include "J${stateUpdaterName}.hpp"
+#include "views/${component}.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace ${cxxNamespace} {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<${stateClassName}>;
+
+void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<${JHybridTSpec}::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  ${JHybridTSpec}* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const ${stateClassName}& data = concreteState->getData();
+  const std::optional<${propsClassName}>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("${stateClassName}'s data doesn't contain any props!");
+  }
+  const ${propsClassName}& props = maybeProps.value();
+  ${indent(propsUpdaterCalls.join('\n'), '  ')}
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<${JHybridTSpec}> shared = javaView->cthis()->shared_cast<${JHybridTSpec}>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace ${cxxNamespace}
+`.trim();
+    addJNINativeRegistration({
+        namespace: cxxNamespace,
+        className: `J${stateUpdaterName}`,
+        import: {
+            name: `views/J${stateUpdaterName}.hpp`,
+            space: 'user',
+            language: 'c++',
+        },
+    });
+    return [
+        ...cppFiles,
+        {
+            content: viewManagerCode,
+            language: 'kotlin',
+            name: `${manager}.kt`,
+            platform: 'android',
+            subdirectory: [...javaSubNamespace.split('.')],
+        },
+        {
+            content: updaterKotlinCode,
+            language: 'kotlin',
+            name: `${stateUpdaterName}.kt`,
+            platform: 'android',
+            subdirectory: [...javaSubNamespace.split('.')],
+        },
+        {
+            content: updaterJniHeaderCode,
+            language: 'c++',
+            name: `J${stateUpdaterName}.hpp`,
+            platform: 'android',
+            subdirectory: ['views'],
+        },
+        {
+            content: updaterJniCppCode,
+            language: 'c++',
+            name: `J${stateUpdaterName}.cpp`,
+            platform: 'android',
+            subdirectory: ['views'],
+        },
+    ];
+}

package/lib/views/swift/SwiftHybridViewManager.js

@@ -0,0 +1,131 @@
+import { createViewComponentShadowNodeFiles, getViewComponentNames, } from '../CppHybridViewComponent.js';
+import { createFileMetadataString, escapeCppName, } from '../../syntax/helpers.js';
+import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrellaHeader.js';
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js';
+import { getHybridObjectConstructorCall } from '../../syntax/swift/SwiftHybridObjectRegistration.js';
+import { indent } from '../../utils.js';
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js';
+export function createSwiftHybridViewManager(spec) {
+    const cppFiles = createViewComponentShadowNodeFiles(spec);
+    const namespace = spec.config.getCxxNamespace('c++');
+    const swiftNamespace = spec.config.getIosModuleName();
+    const { HybridTSpec, HybridTSpecSwift, HybridTSpecCxx } = getHybridObjectName(spec.name);
+    const { component, descriptorClassName, propsClassName } = getViewComponentNames(spec);
+    const autolinking = spec.config.getAutolinkedHybridObjects();
+    const viewImplementation = autolinking[spec.name]?.swift;
+    if (viewImplementation == null) {
+        throw new Error(`Cannot create Swift HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`);
+    }
+    const propAssignments = spec.properties.map((p) => {
+        const name = escapeCppName(p.name);
+        const setter = p.getSetterName('swift');
+        const bridge = new SwiftCxxBridgedType(p.type, false);
+        const parse = bridge.parseFromCppToSwift(`newViewProps.${name}.value`, 'c++');
+        return `
+// ${p.jsSignature}
+if (newViewProps.${name}.isDirty) {
+  swiftPart.${setter}(${indent(parse, '  ')});
+  newViewProps.${name}.isDirty = false;
+}
+`.trim();
+    });
+    const mmFile = `
+${createFileMetadataString(`${component}.mm`)}
+
+#import "${component}.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "${HybridTSpecSwift}.hpp"
+#import "${getUmbrellaHeaderName()}"
+
+using namespace facebook;
+using namespace ${namespace};
+using namespace ${namespace}::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "${spec.name}" HybridView.
+ */
+@interface ${component}: RCTViewComponentView
+@end
+
+@implementation ${component} {
+  std::shared_ptr<${HybridTSpecSwift}> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[${component} class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<${descriptorClassName}>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<${HybridTSpec}> hybridView = ${getHybridObjectConstructorCall(spec.name)}
+    _hybridView = std::dynamic_pointer_cast<${HybridTSpecSwift}>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<${propsClassName} const>(props);
+  auto& newViewProps = const_cast<${propsClassName}&>(newViewPropsConst);
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  ${indent(propAssignments.join('\n'), '  ')}
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+  `;
+    return [
+        ...cppFiles,
+        {
+            content: mmFile,
+            language: 'c++',
+            name: `${component}.mm`,
+            platform: 'ios',
+            subdirectory: ['views'],
+        },
+    ];
+}

package/lib/writeFile.js

@@ -0,0 +1,19 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { capitalizeName } from './utils.js';
+import chalk from 'chalk';
+import { Logger } from './Logger.js';
+/**
+ * Writes the given file to disk and returns it's actual path.
+ */
+export async function writeFile(basePath, file) {
+    const filepath = path.join(basePath, ...file.subdirectory, file.name);
+    const language = capitalizeName(file.language);
+    Logger.debug(`          ${chalk.dim(language)}: Creating ${file.name}...`);
+    const dir = path.dirname(filepath);
+    // Create directory if it doesn't exist yet
+    await fs.mkdir(dir, { recursive: true });
+    // Write file
+    await fs.writeFile(filepath, file.content.trim() + '\n', 'utf8');
+    return filepath;
+}

package/package.json

@@ -1,40 +1,69 @@
 {
   "name": "nitrogen",
-  "homepage": "https://github.com/nitrogenjs/client",
-  "author": "Tim Park <timfpark@gmail.com>",
-  "licenses": [
-    {
-      "type": "Apache",
-      "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
-    }
+  "version": "0.29.5",
+  "description": "The code-generator for react-native-nitro-modules.",
+  "main": "lib/index",
+  "types": "lib/index.d.ts",
+  "source": "src/index",
+  "type": "module",
+  "files": [
+    "lib",
+    "src",
+    "README.md"
   ],
-  "main": "./lib",
+  "bin": "./lib/index.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nitrogenjs/client.git"
+    "url": "git+https://github.com/mrousavy/nitro.git"
   },
-  "version": "0.2.24",
-  "dependencies": {
-    "async": "~0.2.10",
-    "request": "~2.36.0",
-    "socket.io-client": "~0.9.16"
+  "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mrousavy/nitro/issues"
   },
-  "devDependencies": {
-    "nitrogen-browser-request": "~0.3.2",
-    "mocha": "~1.17.1",
-    "uglify-js": "~2.4.13",
-    "jsdox": "~0.2.6"
+  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "test": "mocha",
-    "postpublish": "scripts/build-documentation"
+    "postinstall": "bun build || exit 0;",
+    "build": "bun tsc",
+    "start": "tsc && node lib/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
+    "release": "release-it"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "react-native-nitro-modules": "^0.29.5",
+    "ts-morph": "^25.0.0",
+    "yargs": "^17.7.2",
+    "zod": "^4.0.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.8.4"
   },
-  "keywords": [
-    "devices",
-    "iot",
-    "nitrogen",
-    "pi",
-    "raspberry",
-    "raspberry pi"
-  ]
+  "release-it": {
+    "npm": {
+      "publish": true
+    },
+    "git": false,
+    "github": {
+      "release": false
+    },
+    "hooks": {
+      "before:init": "bun typecheck && bun lint",
+      "after:bump": "bun run build"
+    },
+    "plugins": {
+      "@release-it/bumper": {
+        "out": {
+          "file": "package.json",
+          "path": "dependencies.react-native-nitro-modules",
+          "versionPrefix": "^"
+        }
+      }
+    }
+  }
 }

package/src/Logger.ts

@@ -0,0 +1,63 @@
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error'
+const levelMap = {
+  debug: 0,
+  info: 1,
+  warning: 2,
+  error: 3,
+} as const
+let currentLogLevel: LogLevel = 'info'
+
+export function isValidLogLevel(level: unknown): level is LogLevel {
+  // @ts-expect-error
+  return typeof levelMap[level] === 'number'
+}
+
+export function setLogLevel(level: LogLevel) {
+  currentLogLevel = level
+}
+
+function isAtLeast(level: LogLevel): boolean {
+  return levelMap[level] >= levelMap[currentLogLevel]
+}
+
+let indentation = 0
+
+function getIndentation(): string {
+  let string = ''
+  for (let i = 0; i < indentation; i++) {
+    string += '  '
+  }
+  return string
+}
+
+export const Logger = {
+  withIndented(callback: () => void) {
+    try {
+      indentation++
+      callback()
+    } finally {
+      indentation--
+    }
+  },
+
+  debug(message: string, ...extra: unknown[]) {
+    if (isAtLeast('debug')) {
+      console.debug(getIndentation() + message, ...extra)
+    }
+  },
+  info(message: string, ...extra: unknown[]) {
+    if (isAtLeast('info')) {
+      console.info(getIndentation() + message, ...extra)
+    }
+  },
+  warn(message: string, ...extra: unknown[]) {
+    if (isAtLeast('warning')) {
+      console.warn(getIndentation() + message, ...extra)
+    }
+  },
+  error(message: string, ...extra: unknown[]) {
+    if (isAtLeast('error')) {
+      console.error(getIndentation() + message, ...extra)
+    }
+  },
+}

package/src/autolinking/Autolinking.ts

@@ -0,0 +1,9 @@
+import type { Platform } from '../getPlatformSpecs.js'
+import type { SourceFile } from '../syntax/SourceFile.js'
+
+type AutolinkingFile = Omit<SourceFile, 'language'>
+
+export interface Autolinking {
+  platform: Platform
+  sourceFiles: AutolinkingFile[]
+}

package/src/autolinking/android/createCMakeExtension.ts

@@ -0,0 +1,126 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent, toLowerCamelCase, toUnixPath } from '../../utils.js'
+import {
+  createFileMetadataString,
+  getRelativeDirectory,
+  getRelativeDirectoryGenerated,
+  isCppFile,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface CMakeFile extends Omit<SourceFile, 'language'> {
+  language: 'cmake'
+}
+
+export function getBuildingWithGeneratedCmakeDefinition(): string {
+  const moduleName = NitroConfig.current.getAndroidCxxLibName()
+  const upper = toLowerCamelCase(moduleName).toUpperCase()
+  return `BUILDING_${upper}_WITH_GENERATED_CMAKE_PROJECT`
+}
+
+export function createCMakeExtension(files: SourceFile[]): CMakeFile {
+  const name = NitroConfig.current.getAndroidCxxLibName()
+  const sharedFiles = files
+    .filter((f) => f.platform === 'shared' && isCppFile(f))
+    .map((f) => getRelativeDirectory(f))
+    .map((p) => toUnixPath(p))
+    .filter(isNotDuplicate)
+  const androidFiles = files
+    .filter((f) => f.platform === 'android' && isCppFile(f))
+    .map((f) => getRelativeDirectory(f))
+    .map((p) => toUnixPath(p))
+    .filter(isNotDuplicate)
+  const autolinkingFilePath = getRelativeDirectoryGenerated(
+    'android',
+    `${name}OnLoad.cpp`
+  )
+  const autolinkingFile = toUnixPath(autolinkingFilePath)
+  const buildingWithDefinition = getBuildingWithGeneratedCmakeDefinition()
+
+  const code = `
+${createFileMetadataString(`${name}+autolinking.cmake`, '#')}
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# \`\`\`cmake
+# include(\${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/${name}+autolinking.cmake)
+# \`\`\`
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  ${name} PRIVATE
+  # Autolinking Setup
+  ${autolinkingFile}
+  # Shared Nitrogen C++ sources
+  ${indent(sharedFiles.join('\n'), '  ')}
+  # Android-specific Nitrogen C++ sources
+  ${indent(androidFiles.join('\n'), '  ')}
+)
+
+# Define a flag to check if we are building properly
+add_definitions(-D${buildingWithDefinition})
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+ target_compile_definitions(
+  ${name} PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        ${name}
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        ${name}
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ${name}
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()
+  `.trim()
+  return {
+    content: code,
+    language: 'cmake',
+    name: `${name}+autolinking.cmake`,
+    platform: 'android',
+    subdirectory: [],
+  }
+}