react-native-list 1.0.1 → 2.0.0-alpha.1

package/metro/RendererProxyThreadSwitch.js

@@ -0,0 +1,66 @@
+'use strict'
+
+function isReactNativeRuntime() {
+  return global.__RUNTIME_KIND === 1
+}
+
+let cachedReactNativeRendererProxy
+function getReactNativeRendererProxy() {
+  if (cachedReactNativeRendererProxy == null) {
+    // Intentionally lazy: avoid loading the default RN renderer in non-RN runtimes.
+    // eslint-disable-next-line @react-native/no-deep-imports
+    cachedReactNativeRendererProxy = require('react-native/Libraries/ReactNative/RendererProxy')
+  }
+  return cachedReactNativeRendererProxy
+}
+
+function getNodeFromInternalInstanceHandle(internalInstanceHandle) {
+  if (isReactNativeRuntime()) {
+    return getReactNativeRendererProxy().getNodeFromInternalInstanceHandle(
+      internalInstanceHandle
+    )
+  }
+
+  const stateNode = internalInstanceHandle?.stateNode
+  if (stateNode == null) {
+    return null
+  }
+  return stateNode.node ?? stateNode
+}
+
+function getPublicInstanceFromInternalInstanceHandle(internalInstanceHandle) {
+  if (isReactNativeRuntime()) {
+    return getReactNativeRendererProxy().getPublicInstanceFromInternalInstanceHandle(
+      internalInstanceHandle
+    )
+  }
+
+  const stateNode = internalInstanceHandle?.stateNode
+  if (stateNode == null) {
+    return null
+  }
+
+  if (stateNode.canonical?.publicInstance != null) {
+    return stateNode.canonical.publicInstance
+  }
+
+  return stateNode.node ?? stateNode
+}
+
+function getPublicInstanceFromRootTag(rootTag) {
+  if (isReactNativeRuntime()) {
+    return getReactNativeRendererProxy().getPublicInstanceFromRootTag(rootTag)
+  }
+
+  if (global.rootInstance?.containerTag === Number(rootTag)) {
+    return global.rootInstance.publicInstance ?? null
+  }
+
+  return null
+}
+
+module.exports = {
+  getNodeFromInternalInstanceHandle,
+  getPublicInstanceFromInternalInstanceHandle,
+  getPublicInstanceFromRootTag,
+}

package/metro-config.d.ts

@@ -0,0 +1 @@
+export function getReactNativeListMetroConfig<TConfig>(config: TConfig): TConfig

package/metro-config.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const path = require('path')
+
+const rendererProxyThreadSwitchPath = path.resolve(
+  __dirname,
+  'metro/RendererProxyThreadSwitch.js'
+)
+
+function isRendererProxyImport(moduleName) {
+  return /(?:^|\/)RendererProxy(?:\.js)?$/.test(moduleName)
+}
+
+function isReactNativeDomInternalsImporter(originModulePath) {
+  if (typeof originModulePath !== 'string') {
+    return false
+  }
+
+  return originModulePath.includes(
+    `${path.sep}node_modules${path.sep}react-native${path.sep}src${path.sep}private${path.sep}webapis${path.sep}dom${path.sep}nodes${path.sep}internals${path.sep}`
+  )
+}
+
+function getReactNativeListMetroConfig(config) {
+  config.resolver = config.resolver || {}
+  const currentResolveRequest = config.resolver.resolveRequest
+
+  config.resolver.resolveRequest = (context, moduleName, platform) => {
+    // Redirect only React Native DOM internals to a runtime-switching proxy.
+    if (
+      isRendererProxyImport(moduleName) &&
+      isReactNativeDomInternalsImporter(context.originModulePath)
+    ) {
+      return {
+        type: 'sourceFile',
+        filePath: rendererProxyThreadSwitchPath,
+      }
+    }
+
+    return (currentResolveRequest || context.resolveRequest)(
+      context,
+      moduleName,
+      platform
+    )
+  }
+
+  return config
+}
+
+module.exports = {
+  getReactNativeListMetroConfig,
+}

package/nitro.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "reactnativelist"
+  ],
+  "ios": {
+    "iosModuleName": "ReactNativeList"
+  },
+  "android": {
+    "androidNamespace": [
+      "reactnativelist"
+    ],
+    "androidCxxLibName": "ReactNativeList"
+  },
+  "autolinking": {
+    "ViewHolder": {
+      "kotlin": "HybridViewHolder",
+      "swift": "HybridViewHolder"
+    },
+    "UiListView": {
+      "kotlin": "HybridUiListView",
+      "swift": "HybridUiListView"
+    },
+    "NativeListDataSource": {
+      "kotlin": "HybridNativeListDataSource",
+      "swift": "HybridNativeListDataSource"
+    },
+    "NativeListLayout": {
+      "kotlin": "HybridNativeListLayout",
+      "swift": "HybridNativeListLayout"
+    },
+    "NativeLinearListLayout": {
+      "kotlin": "HybridNativeLinearListLayout",
+      "swift": "HybridNativeLinearListLayout"
+    },
+    "UiListModule": {
+      "kotlin": "HybridUiListModule",
+      "swift": "HybridUiListModule"
+    },
+    "UiManagerHelper": {
+      "cpp": "HybridUiManagerHelper"
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules"
+  ]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/ReactNativeList+autolinking.cmake

@@ -0,0 +1,99 @@
+#
+# ReactNativeList+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# 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/ReactNativeList+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_REACTNATIVELIST_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# 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)
+  ReactNativeList PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/ReactNativeListOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridIOSWorkletsModuleProxyHolderSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeLinearListLayoutSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeListDataSourceSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeListLayoutSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUiListModuleSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUiListViewSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridUiListViewComponent.cpp
+  ../nitrogen/generated/shared/c++/HybridUiManagerHelperSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridViewHolderSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridViewHolderComponent.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridIOSWorkletsModuleProxyHolderSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeLinearListLayoutSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeListDataSourceSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeListLayoutSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridUiListModuleSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_HybridIOSWorkletsModuleProxyHolderSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridUiListViewSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridUiListViewStateUpdater.cpp
+  ../nitrogen/generated/android/c++/JHybridViewHolderSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridViewHolderStateUpdater.cpp
+)
+
+# 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(
+  ReactNativeList 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(
+        ReactNativeList
+        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(
+        ReactNativeList
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ReactNativeList
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/ReactNativeList+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// ReactNativeList+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/ReactNativeList+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 ReactNativeList is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/ReactNativeListOnLoad.cpp

@@ -0,0 +1,156 @@
+///
+/// ReactNativeListOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_REACTNATIVELIST_WITH_GENERATED_CMAKE_PROJECT
+#error ReactNativeListOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "ReactNativeListOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridIOSWorkletsModuleProxyHolderSpec.hpp"
+#include "JHybridNativeLinearListLayoutSpec.hpp"
+#include "JHybridNativeListDataSourceSpec.hpp"
+#include "JFunc_bool_NativeListItem_NativeListItem.hpp"
+#include "JHybridNativeListLayoutSpec.hpp"
+#include "JHybridUiListModuleSpec.hpp"
+#include "JHybridUiListViewSpec.hpp"
+#include "JFunc_double_std__string.hpp"
+#include "JFunc_bool_double_NativeListItem_double.hpp"
+#include "views/JHybridUiListViewStateUpdater.hpp"
+#include "JHybridViewHolderSpec.hpp"
+#include "views/JHybridViewHolderStateUpdater.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+#include "HybridUiManagerHelper.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::reactnativelist::registerAllNatives();
+  });
+}
+
+struct JHybridViewHolderSpecImpl: public jni::JavaClass<JHybridViewHolderSpecImpl, JHybridViewHolderSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridViewHolder;";
+  static std::shared_ptr<JHybridViewHolderSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridViewHolderSpecImpl::javaobject()>();
+    jni::local_ref<JHybridViewHolderSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridViewHolderSpec();
+  }
+};
+struct JHybridUiListViewSpecImpl: public jni::JavaClass<JHybridUiListViewSpecImpl, JHybridUiListViewSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridUiListView;";
+  static std::shared_ptr<JHybridUiListViewSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridUiListViewSpecImpl::javaobject()>();
+    jni::local_ref<JHybridUiListViewSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridUiListViewSpec();
+  }
+};
+struct JHybridNativeListDataSourceSpecImpl: public jni::JavaClass<JHybridNativeListDataSourceSpecImpl, JHybridNativeListDataSourceSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridNativeListDataSource;";
+  static std::shared_ptr<JHybridNativeListDataSourceSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNativeListDataSourceSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNativeListDataSourceSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNativeListDataSourceSpec();
+  }
+};
+struct JHybridNativeListLayoutSpecImpl: public jni::JavaClass<JHybridNativeListLayoutSpecImpl, JHybridNativeListLayoutSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridNativeListLayout;";
+  static std::shared_ptr<JHybridNativeListLayoutSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNativeListLayoutSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNativeListLayoutSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNativeListLayoutSpec();
+  }
+};
+struct JHybridNativeLinearListLayoutSpecImpl: public jni::JavaClass<JHybridNativeLinearListLayoutSpecImpl, JHybridNativeLinearListLayoutSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridNativeLinearListLayout;";
+  static std::shared_ptr<JHybridNativeLinearListLayoutSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNativeLinearListLayoutSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNativeLinearListLayoutSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNativeLinearListLayoutSpec();
+  }
+};
+struct JHybridUiListModuleSpecImpl: public jni::JavaClass<JHybridUiListModuleSpecImpl, JHybridUiListModuleSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/HybridUiListModule;";
+  static std::shared_ptr<JHybridUiListModuleSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridUiListModuleSpecImpl::javaobject()>();
+    jni::local_ref<JHybridUiListModuleSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridUiListModuleSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::reactnativelist;
+
+  // Register native JNI methods
+  margelo::nitro::reactnativelist::JHybridIOSWorkletsModuleProxyHolderSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JHybridNativeLinearListLayoutSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JHybridNativeListDataSourceSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JFunc_bool_NativeListItem_NativeListItem_cxx::registerNatives();
+  margelo::nitro::reactnativelist::JHybridNativeListLayoutSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JHybridUiListModuleSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JHybridUiListViewSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::JFunc_double_std__string_cxx::registerNatives();
+  margelo::nitro::reactnativelist::JFunc_bool_double_NativeListItem_double_cxx::registerNatives();
+  margelo::nitro::reactnativelist::views::JHybridUiListViewStateUpdater::registerNatives();
+  margelo::nitro::reactnativelist::JHybridViewHolderSpec::CxxPart::registerNatives();
+  margelo::nitro::reactnativelist::views::JHybridViewHolderStateUpdater::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewHolder",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridViewHolderSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "UiListView",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridUiListViewSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NativeListDataSource",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNativeListDataSourceSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NativeListLayout",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNativeListLayoutSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NativeLinearListLayout",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNativeLinearListLayoutSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "UiListModule",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridUiListModuleSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "UiManagerHelper",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridUiManagerHelper>,
+                    "The HybridObject \"HybridUiManagerHelper\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridUiManagerHelper>();
+    }
+  );
+}
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/android/ReactNativeListOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// ReactNativeListOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::reactnativelist {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of ReactNativeList, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all ReactNativeList HybridObjects
+   *     margelo::nitro::reactnativelist::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/android/c++/JFunc_bool_NativeListItem_NativeListItem.hpp

@@ -0,0 +1,83 @@
+///
+/// JFunc_bool_NativeListItem_NativeListItem.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "NativeListItem.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JNativeListItem.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::reactnativelist {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(oldItem: NativeListItem, newItem: NativeListItem) -> Boolean`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_bool_NativeListItem_NativeListItem: public jni::JavaClass<JFunc_bool_NativeListItem_NativeListItem> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/Func_bool_NativeListItem_NativeListItem;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_bool_NativeListItem_NativeListItem` instance holds through JNI.
+     */
+    bool invoke(const NativeListItem& oldItem, const NativeListItem& newItem) const {
+      static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JNativeListItem> /* oldItem */, jni::alias_ref<JNativeListItem> /* newItem */)>("invoke");
+      auto __result = method(self(), JNativeListItem::fromCpp(oldItem), JNativeListItem::fromCpp(newItem));
+      return static_cast<bool>(__result);
+    }
+  };
+
+  /**
+   * An implementation of Func_bool_NativeListItem_NativeListItem that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_bool_NativeListItem_NativeListItem_cxx final: public jni::HybridClass<JFunc_bool_NativeListItem_NativeListItem_cxx, JFunc_bool_NativeListItem_NativeListItem> {
+  public:
+    static jni::local_ref<JFunc_bool_NativeListItem_NativeListItem::javaobject> fromCpp(const std::function<bool(const NativeListItem& /* oldItem */, const NativeListItem& /* newItem */)>& func) {
+      return JFunc_bool_NativeListItem_NativeListItem_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_bool_NativeListItem_NativeListItem_cxx` instance holds.
+     */
+    jboolean invoke_cxx(jni::alias_ref<JNativeListItem> oldItem, jni::alias_ref<JNativeListItem> newItem) {
+      bool __result = _func(oldItem->toCpp(), newItem->toCpp());
+      return __result;
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<bool(const NativeListItem& /* oldItem */, const NativeListItem& /* newItem */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/Func_bool_NativeListItem_NativeListItem_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_bool_NativeListItem_NativeListItem_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_bool_NativeListItem_NativeListItem_cxx(const std::function<bool(const NativeListItem& /* oldItem */, const NativeListItem& /* newItem */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<bool(const NativeListItem& /* oldItem */, const NativeListItem& /* newItem */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/android/c++/JFunc_bool_double_NativeListItem_double.hpp

@@ -0,0 +1,83 @@
+///
+/// JFunc_bool_double_NativeListItem_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "NativeListItem.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JNativeListItem.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::reactnativelist {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(reactTag: Double, item: NativeListItem, index: Double) -> Boolean`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_bool_double_NativeListItem_double: public jni::JavaClass<JFunc_bool_double_NativeListItem_double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/Func_bool_double_NativeListItem_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_bool_double_NativeListItem_double` instance holds through JNI.
+     */
+    bool invoke(double reactTag, const NativeListItem& item, double index) const {
+      static const auto method = javaClassStatic()->getMethod<jboolean(double /* reactTag */, jni::alias_ref<JNativeListItem> /* item */, double /* index */)>("invoke");
+      auto __result = method(self(), reactTag, JNativeListItem::fromCpp(item), index);
+      return static_cast<bool>(__result);
+    }
+  };
+
+  /**
+   * An implementation of Func_bool_double_NativeListItem_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_bool_double_NativeListItem_double_cxx final: public jni::HybridClass<JFunc_bool_double_NativeListItem_double_cxx, JFunc_bool_double_NativeListItem_double> {
+  public:
+    static jni::local_ref<JFunc_bool_double_NativeListItem_double::javaobject> fromCpp(const std::function<bool(double /* reactTag */, const NativeListItem& /* item */, double /* index */)>& func) {
+      return JFunc_bool_double_NativeListItem_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_bool_double_NativeListItem_double_cxx` instance holds.
+     */
+    jboolean invoke_cxx(double reactTag, jni::alias_ref<JNativeListItem> item, double index) {
+      bool __result = _func(reactTag, item->toCpp(), index);
+      return __result;
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<bool(double /* reactTag */, const NativeListItem& /* item */, double /* index */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativelist/Func_bool_double_NativeListItem_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_bool_double_NativeListItem_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_bool_double_NativeListItem_double_cxx(const std::function<bool(double /* reactTag */, const NativeListItem& /* item */, double /* index */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<bool(double /* reactTag */, const NativeListItem& /* item */, double /* index */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativelist