@onekeyfe/react-native-auto-size-input 1.0.1

package/lib/nitrogen/generated/shared/c++/views/HybridAutoSizeInputComponent.hpp

@@ -0,0 +1,133 @@
+///
+/// HybridAutoSizeInputComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include <functional>
+#include <memory>
+#include "HybridAutoSizeInputSpec.hpp"
+
+namespace margelo::nitro::autosizeinput::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAutoSizeInputComponentName[];
+
+  /**
+   * Props for the "AutoSizeInput" View.
+   */
+  class HybridAutoSizeInputProps final: public react::ViewProps {
+  public:
+    HybridAutoSizeInputProps() = default;
+    HybridAutoSizeInputProps(const HybridAutoSizeInputProps&);
+    HybridAutoSizeInputProps(const react::PropsParserContext& context,
+                             const HybridAutoSizeInputProps& sourceProps,
+                             const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::string>> text;
+    CachedProp<std::optional<std::string>> prefix;
+    CachedProp<std::optional<std::string>> suffix;
+    CachedProp<std::optional<std::string>> placeholder;
+    CachedProp<std::optional<double>> fontSize;
+    CachedProp<std::optional<double>> minFontSize;
+    CachedProp<std::optional<bool>> multiline;
+    CachedProp<std::optional<double>> maxNumberOfLines;
+    CachedProp<std::optional<std::string>> textColor;
+    CachedProp<std::optional<std::string>> prefixColor;
+    CachedProp<std::optional<std::string>> suffixColor;
+    CachedProp<std::optional<std::string>> placeholderColor;
+    CachedProp<std::optional<std::string>> textAlign;
+    CachedProp<std::optional<std::string>> fontFamily;
+    CachedProp<std::optional<std::string>> fontWeight;
+    CachedProp<std::optional<bool>> editable;
+    CachedProp<std::optional<std::string>> keyboardType;
+    CachedProp<std::optional<std::string>> returnKeyType;
+    CachedProp<std::optional<bool>> autoCorrect;
+    CachedProp<std::optional<std::string>> autoCapitalize;
+    CachedProp<std::optional<std::string>> selectionColor;
+    CachedProp<std::optional<double>> prefixMarginRight;
+    CachedProp<std::optional<double>> suffixMarginLeft;
+    CachedProp<std::optional<std::function<void(const std::string& /* text */)>>> onChangeText;
+    CachedProp<std::optional<std::function<void()>>> onFocus;
+    CachedProp<std::optional<std::function<void()>>> onBlur;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAutoSizeInputSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "AutoSizeInput" View.
+   */
+  class HybridAutoSizeInputState final {
+  public:
+    HybridAutoSizeInputState() = default;
+
+  public:
+    void setProps(const HybridAutoSizeInputProps& props) { _props.emplace(props); }
+    const std::optional<HybridAutoSizeInputProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAutoSizeInputState(const HybridAutoSizeInputState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAutoSizeInputState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAutoSizeInputState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAutoSizeInputProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "AutoSizeInput" View.
+   */
+  using HybridAutoSizeInputShadowNode = react::ConcreteViewShadowNode<HybridAutoSizeInputComponentName /* "HybridAutoSizeInput" */,
+                                                                      HybridAutoSizeInputProps /* custom props */,
+                                                                      react::ViewEventEmitter /* default */,
+                                                                      HybridAutoSizeInputState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "AutoSizeInput" View.
+   */
+  class HybridAutoSizeInputComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAutoSizeInputShadowNode> {
+  public:
+    HybridAutoSizeInputComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAutoSizeInputProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "AutoSizeInput" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::autosizeinput::views

package/lib/nitrogen/generated/shared/json/AutoSizeInputConfig.json

@@ -0,0 +1,35 @@
+{
+  "uiViewClassName": "AutoSizeInput",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "text": true,
+    "prefix": true,
+    "suffix": true,
+    "placeholder": true,
+    "fontSize": true,
+    "minFontSize": true,
+    "multiline": true,
+    "maxNumberOfLines": true,
+    "textColor": true,
+    "prefixColor": true,
+    "suffixColor": true,
+    "placeholderColor": true,
+    "textAlign": true,
+    "fontFamily": true,
+    "fontWeight": true,
+    "editable": true,
+    "keyboardType": true,
+    "returnKeyType": true,
+    "autoCorrect": true,
+    "autoCapitalize": true,
+    "selectionColor": true,
+    "prefixMarginRight": true,
+    "suffixMarginLeft": true,
+    "onChangeText": true,
+    "onFocus": true,
+    "onBlur": true,
+    "hybridRef": true
+  }
+}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/AutoSizeInput.nitro.d.ts

@@ -0,0 +1,35 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export interface AutoSizeInputProps extends HybridViewProps {
+    text?: string;
+    prefix?: string;
+    suffix?: string;
+    placeholder?: string;
+    fontSize?: number;
+    minFontSize?: number;
+    multiline?: boolean;
+    maxNumberOfLines?: number;
+    textColor?: string;
+    prefixColor?: string;
+    suffixColor?: string;
+    placeholderColor?: string;
+    textAlign?: string;
+    fontFamily?: string;
+    fontWeight?: string;
+    editable?: boolean;
+    keyboardType?: string;
+    returnKeyType?: string;
+    autoCorrect?: boolean;
+    autoCapitalize?: string;
+    selectionColor?: string;
+    prefixMarginRight?: number;
+    suffixMarginLeft?: number;
+    onChangeText?: (text: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+}
+export interface AutoSizeInputMethods extends HybridViewMethods {
+    focus(): void;
+    blur(): void;
+}
+export type AutoSizeInput = HybridView<AutoSizeInputProps, AutoSizeInputMethods>;
+//# sourceMappingURL=AutoSizeInput.nitro.d.ts.map

package/lib/typescript/src/AutoSizeInput.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoSizeInput.nitro.d.ts","sourceRoot":"","sources":["../../../src/AutoSizeInput.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IAEzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAG1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAGnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IAGxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAG1B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;CACd;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { AutoSizeInputMethods, AutoSizeInputProps } from './AutoSizeInput.nitro';
+export type { AutoSizeInputMethods, AutoSizeInputProps };
+export declare const AutoSizeInputView: import("react-native-nitro-modules").ReactNativeView<AutoSizeInputProps, AutoSizeInputMethods>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,CAAC;AAEzD,eAAO,MAAM,iBAAiB,gGAGe,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["autosizeinput"],
+  "ios": {
+    "iosModuleName": "AutoSizeInput"
+  },
+  "android": {
+    "androidNamespace": ["autosizeinput"],
+    "androidCxxLibName": "autosizeinput"
+  },
+  "autolinking": {
+    "AutoSizeInput": {
+      "swift": "HybridAutoSizeInput",
+      "kotlin": "HybridAutoSizeInput"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

@@ -0,0 +1,83 @@
+#
+# autosizeinput+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2026 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/autosizeinput+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_AUTOSIZEINPUT_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)
+  autosizeinput PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/autosizeinputOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAutoSizeInputSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridAutoSizeInputComponent.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridAutoSizeInputSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridAutoSizeInputStateUpdater.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(
+  autosizeinput 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(
+        autosizeinput
+        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(
+        autosizeinput
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        autosizeinput
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

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

@@ -0,0 +1,27 @@
+///
+/// autosizeinput+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 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/autosizeinput+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 autosizeinput is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/autosizeinputOnLoad.cpp

@@ -0,0 +1,50 @@
+///
+/// autosizeinputOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_AUTOSIZEINPUT_WITH_GENERATED_CMAKE_PROJECT
+#error autosizeinputOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "autosizeinputOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridAutoSizeInputSpec.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "JFunc_void.hpp"
+#include "views/JHybridAutoSizeInputStateUpdater.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::autosizeinput {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::autosizeinput;
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    margelo::nitro::autosizeinput::JHybridAutoSizeInputSpec::registerNatives();
+    margelo::nitro::autosizeinput::JFunc_void_std__string_cxx::registerNatives();
+    margelo::nitro::autosizeinput::JFunc_void_cxx::registerNatives();
+    margelo::nitro::autosizeinput::views::JHybridAutoSizeInputStateUpdater::registerNatives();
+
+    // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AutoSizeInput",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAutoSizeInputSpec::javaobject> object("com/margelo/nitro/autosizeinput/HybridAutoSizeInput");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+  });
+}
+
+} // namespace margelo::nitro::autosizeinput

package/nitrogen/generated/android/autosizeinputOnLoad.hpp

@@ -0,0 +1,25 @@
+///
+/// autosizeinputOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::autosizeinput {
+
+  /**
+   * Initializes the native (C++) part of autosizeinput, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return margelo::nitro::autosizeinput::initialize(vm);
+   * }
+   * ```
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace margelo::nitro::autosizeinput

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

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

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::autosizeinput {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(text: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& text) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("invoke");
+      method(self(), jni::make_jstring(text));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* text */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> text) {
+      _func(text->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* text */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* text */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* text */)> _func;
+  };
+
+} // namespace margelo::nitro::autosizeinput