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

package/nitrogen/generated/android/c++/JHybridAutoSizeInputSpec.cpp

@@ -0,0 +1,317 @@
+///
+/// JHybridAutoSizeInputSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAutoSizeInputSpec.hpp"
+
+
+
+#include <string>
+#include <optional>
+#include <functional>
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void.hpp"
+
+namespace margelo::nitro::autosizeinput {
+
+  jni::local_ref<JHybridAutoSizeInputSpec::jhybriddata> JHybridAutoSizeInputSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAutoSizeInputSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAutoSizeInputSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAutoSizeInputSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAutoSizeInputSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAutoSizeInputSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::string> JHybridAutoSizeInputSpec::getText() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getText");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setText(const std::optional<std::string>& text) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("setText");
+    method(_javaPart, text.has_value() ? jni::make_jstring(text.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getPrefix() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPrefix");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setPrefix(const std::optional<std::string>& prefix) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* prefix */)>("setPrefix");
+    method(_javaPart, prefix.has_value() ? jni::make_jstring(prefix.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getSuffix() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSuffix");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setSuffix(const std::optional<std::string>& suffix) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* suffix */)>("setSuffix");
+    method(_javaPart, suffix.has_value() ? jni::make_jstring(suffix.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getPlaceholder() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPlaceholder");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setPlaceholder(const std::optional<std::string>& placeholder) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* placeholder */)>("setPlaceholder");
+    method(_javaPart, placeholder.has_value() ? jni::make_jstring(placeholder.value()) : nullptr);
+  }
+  std::optional<double> JHybridAutoSizeInputSpec::getFontSize() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getFontSize");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setFontSize(std::optional<double> fontSize) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* fontSize */)>("setFontSize");
+    method(_javaPart, fontSize.has_value() ? jni::JDouble::valueOf(fontSize.value()) : nullptr);
+  }
+  std::optional<double> JHybridAutoSizeInputSpec::getMinFontSize() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMinFontSize");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setMinFontSize(std::optional<double> minFontSize) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* minFontSize */)>("setMinFontSize");
+    method(_javaPart, minFontSize.has_value() ? jni::JDouble::valueOf(minFontSize.value()) : nullptr);
+  }
+  std::optional<bool> JHybridAutoSizeInputSpec::getMultiline() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getMultiline");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setMultiline(std::optional<bool> multiline) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* multiline */)>("setMultiline");
+    method(_javaPart, multiline.has_value() ? jni::JBoolean::valueOf(multiline.value()) : nullptr);
+  }
+  std::optional<double> JHybridAutoSizeInputSpec::getMaxNumberOfLines() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxNumberOfLines");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setMaxNumberOfLines(std::optional<double> maxNumberOfLines) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxNumberOfLines */)>("setMaxNumberOfLines");
+    method(_javaPart, maxNumberOfLines.has_value() ? jni::JDouble::valueOf(maxNumberOfLines.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getTextColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getTextColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setTextColor(const std::optional<std::string>& textColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* textColor */)>("setTextColor");
+    method(_javaPart, textColor.has_value() ? jni::make_jstring(textColor.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getPrefixColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPrefixColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setPrefixColor(const std::optional<std::string>& prefixColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* prefixColor */)>("setPrefixColor");
+    method(_javaPart, prefixColor.has_value() ? jni::make_jstring(prefixColor.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getSuffixColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSuffixColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setSuffixColor(const std::optional<std::string>& suffixColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* suffixColor */)>("setSuffixColor");
+    method(_javaPart, suffixColor.has_value() ? jni::make_jstring(suffixColor.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getPlaceholderColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPlaceholderColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setPlaceholderColor(const std::optional<std::string>& placeholderColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* placeholderColor */)>("setPlaceholderColor");
+    method(_javaPart, placeholderColor.has_value() ? jni::make_jstring(placeholderColor.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getTextAlign() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getTextAlign");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setTextAlign(const std::optional<std::string>& textAlign) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* textAlign */)>("setTextAlign");
+    method(_javaPart, textAlign.has_value() ? jni::make_jstring(textAlign.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getFontFamily() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontFamily");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setFontFamily(const std::optional<std::string>& fontFamily) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontFamily */)>("setFontFamily");
+    method(_javaPart, fontFamily.has_value() ? jni::make_jstring(fontFamily.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getFontWeight() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontWeight");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setFontWeight(const std::optional<std::string>& fontWeight) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontWeight */)>("setFontWeight");
+    method(_javaPart, fontWeight.has_value() ? jni::make_jstring(fontWeight.value()) : nullptr);
+  }
+  std::optional<bool> JHybridAutoSizeInputSpec::getEditable() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEditable");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setEditable(std::optional<bool> editable) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* editable */)>("setEditable");
+    method(_javaPart, editable.has_value() ? jni::JBoolean::valueOf(editable.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getKeyboardType() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getKeyboardType");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setKeyboardType(const std::optional<std::string>& keyboardType) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* keyboardType */)>("setKeyboardType");
+    method(_javaPart, keyboardType.has_value() ? jni::make_jstring(keyboardType.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getReturnKeyType() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getReturnKeyType");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setReturnKeyType(const std::optional<std::string>& returnKeyType) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* returnKeyType */)>("setReturnKeyType");
+    method(_javaPart, returnKeyType.has_value() ? jni::make_jstring(returnKeyType.value()) : nullptr);
+  }
+  std::optional<bool> JHybridAutoSizeInputSpec::getAutoCorrect() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getAutoCorrect");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setAutoCorrect(std::optional<bool> autoCorrect) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* autoCorrect */)>("setAutoCorrect");
+    method(_javaPart, autoCorrect.has_value() ? jni::JBoolean::valueOf(autoCorrect.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getAutoCapitalize() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAutoCapitalize");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setAutoCapitalize(const std::optional<std::string>& autoCapitalize) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* autoCapitalize */)>("setAutoCapitalize");
+    method(_javaPart, autoCapitalize.has_value() ? jni::make_jstring(autoCapitalize.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAutoSizeInputSpec::getSelectionColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSelectionColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setSelectionColor(const std::optional<std::string>& selectionColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* selectionColor */)>("setSelectionColor");
+    method(_javaPart, selectionColor.has_value() ? jni::make_jstring(selectionColor.value()) : nullptr);
+  }
+  std::optional<double> JHybridAutoSizeInputSpec::getPrefixMarginRight() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPrefixMarginRight");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setPrefixMarginRight(std::optional<double> prefixMarginRight) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* prefixMarginRight */)>("setPrefixMarginRight");
+    method(_javaPart, prefixMarginRight.has_value() ? jni::JDouble::valueOf(prefixMarginRight.value()) : nullptr);
+  }
+  std::optional<double> JHybridAutoSizeInputSpec::getSuffixMarginLeft() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getSuffixMarginLeft");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setSuffixMarginLeft(std::optional<double> suffixMarginLeft) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* suffixMarginLeft */)>("setSuffixMarginLeft");
+    method(_javaPart, suffixMarginLeft.has_value() ? jni::JDouble::valueOf(suffixMarginLeft.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* text */)>> JHybridAutoSizeInputSpec::getOnChangeText() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnChangeText_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* text */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setOnChangeText(const std::optional<std::function<void(const std::string& /* text */)>>& onChangeText) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onChangeText */)>("setOnChangeText_cxx");
+    method(_javaPart, onChangeText.has_value() ? JFunc_void_std__string_cxx::fromCpp(onChangeText.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridAutoSizeInputSpec::getOnFocus() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnFocus_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setOnFocus(const std::optional<std::function<void()>>& onFocus) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onFocus */)>("setOnFocus_cxx");
+    method(_javaPart, onFocus.has_value() ? JFunc_void_cxx::fromCpp(onFocus.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridAutoSizeInputSpec::getOnBlur() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnBlur_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAutoSizeInputSpec::setOnBlur(const std::optional<std::function<void()>>& onBlur) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onBlur */)>("setOnBlur_cxx");
+    method(_javaPart, onBlur.has_value() ? JFunc_void_cxx::fromCpp(onBlur.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridAutoSizeInputSpec::focus() {
+    static const auto method = javaClassStatic()->getMethod<void()>("focus");
+    method(_javaPart);
+  }
+  void JHybridAutoSizeInputSpec::blur() {
+    static const auto method = javaClassStatic()->getMethod<void()>("blur");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::autosizeinput

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

@@ -0,0 +1,117 @@
+///
+/// HybridAutoSizeInputSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAutoSizeInputSpec.hpp"
+
+
+
+
+namespace margelo::nitro::autosizeinput {
+
+  using namespace facebook;
+
+  class JHybridAutoSizeInputSpec: public jni::HybridClass<JHybridAutoSizeInputSpec, JHybridObject>,
+                                  public virtual HybridAutoSizeInputSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/HybridAutoSizeInputSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAutoSizeInputSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAutoSizeInputSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAutoSizeInputSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridAutoSizeInputSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getText() override;
+    void setText(const std::optional<std::string>& text) override;
+    std::optional<std::string> getPrefix() override;
+    void setPrefix(const std::optional<std::string>& prefix) override;
+    std::optional<std::string> getSuffix() override;
+    void setSuffix(const std::optional<std::string>& suffix) override;
+    std::optional<std::string> getPlaceholder() override;
+    void setPlaceholder(const std::optional<std::string>& placeholder) override;
+    std::optional<double> getFontSize() override;
+    void setFontSize(std::optional<double> fontSize) override;
+    std::optional<double> getMinFontSize() override;
+    void setMinFontSize(std::optional<double> minFontSize) override;
+    std::optional<bool> getMultiline() override;
+    void setMultiline(std::optional<bool> multiline) override;
+    std::optional<double> getMaxNumberOfLines() override;
+    void setMaxNumberOfLines(std::optional<double> maxNumberOfLines) override;
+    std::optional<std::string> getTextColor() override;
+    void setTextColor(const std::optional<std::string>& textColor) override;
+    std::optional<std::string> getPrefixColor() override;
+    void setPrefixColor(const std::optional<std::string>& prefixColor) override;
+    std::optional<std::string> getSuffixColor() override;
+    void setSuffixColor(const std::optional<std::string>& suffixColor) override;
+    std::optional<std::string> getPlaceholderColor() override;
+    void setPlaceholderColor(const std::optional<std::string>& placeholderColor) override;
+    std::optional<std::string> getTextAlign() override;
+    void setTextAlign(const std::optional<std::string>& textAlign) override;
+    std::optional<std::string> getFontFamily() override;
+    void setFontFamily(const std::optional<std::string>& fontFamily) override;
+    std::optional<std::string> getFontWeight() override;
+    void setFontWeight(const std::optional<std::string>& fontWeight) override;
+    std::optional<bool> getEditable() override;
+    void setEditable(std::optional<bool> editable) override;
+    std::optional<std::string> getKeyboardType() override;
+    void setKeyboardType(const std::optional<std::string>& keyboardType) override;
+    std::optional<std::string> getReturnKeyType() override;
+    void setReturnKeyType(const std::optional<std::string>& returnKeyType) override;
+    std::optional<bool> getAutoCorrect() override;
+    void setAutoCorrect(std::optional<bool> autoCorrect) override;
+    std::optional<std::string> getAutoCapitalize() override;
+    void setAutoCapitalize(const std::optional<std::string>& autoCapitalize) override;
+    std::optional<std::string> getSelectionColor() override;
+    void setSelectionColor(const std::optional<std::string>& selectionColor) override;
+    std::optional<double> getPrefixMarginRight() override;
+    void setPrefixMarginRight(std::optional<double> prefixMarginRight) override;
+    std::optional<double> getSuffixMarginLeft() override;
+    void setSuffixMarginLeft(std::optional<double> suffixMarginLeft) override;
+    std::optional<std::function<void(const std::string& /* text */)>> getOnChangeText() override;
+    void setOnChangeText(const std::optional<std::function<void(const std::string& /* text */)>>& onChangeText) override;
+    std::optional<std::function<void()>> getOnFocus() override;
+    void setOnFocus(const std::optional<std::function<void()>>& onFocus) override;
+    std::optional<std::function<void()>> getOnBlur() override;
+    void setOnBlur(const std::optional<std::function<void()>>& onBlur) override;
+
+  public:
+    // Methods
+    void focus() override;
+    void blur() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAutoSizeInputSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::autosizeinput

package/nitrogen/generated/android/c++/views/JHybridAutoSizeInputStateUpdater.cpp

@@ -0,0 +1,156 @@
+///
+/// JHybridAutoSizeInputStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAutoSizeInputStateUpdater.hpp"
+#include "views/HybridAutoSizeInputComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::autosizeinput::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridAutoSizeInputState>;
+
+void JHybridAutoSizeInputStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAutoSizeInputSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridAutoSizeInputSpec* 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 HybridAutoSizeInputState& data = concreteState->getData();
+  const std::optional<HybridAutoSizeInputProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridAutoSizeInputState's data doesn't contain any props!");
+  }
+  const HybridAutoSizeInputProps& props = maybeProps.value();
+  if (props.text.isDirty) {
+    view->setText(props.text.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.prefix.isDirty) {
+    view->setPrefix(props.prefix.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.suffix.isDirty) {
+    view->setSuffix(props.suffix.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.placeholder.isDirty) {
+    view->setPlaceholder(props.placeholder.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.fontSize.isDirty) {
+    view->setFontSize(props.fontSize.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.minFontSize.isDirty) {
+    view->setMinFontSize(props.minFontSize.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.multiline.isDirty) {
+    view->setMultiline(props.multiline.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.maxNumberOfLines.isDirty) {
+    view->setMaxNumberOfLines(props.maxNumberOfLines.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.textColor.isDirty) {
+    view->setTextColor(props.textColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.prefixColor.isDirty) {
+    view->setPrefixColor(props.prefixColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.suffixColor.isDirty) {
+    view->setSuffixColor(props.suffixColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.placeholderColor.isDirty) {
+    view->setPlaceholderColor(props.placeholderColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.textAlign.isDirty) {
+    view->setTextAlign(props.textAlign.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.fontFamily.isDirty) {
+    view->setFontFamily(props.fontFamily.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.fontWeight.isDirty) {
+    view->setFontWeight(props.fontWeight.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.editable.isDirty) {
+    view->setEditable(props.editable.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.keyboardType.isDirty) {
+    view->setKeyboardType(props.keyboardType.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.returnKeyType.isDirty) {
+    view->setReturnKeyType(props.returnKeyType.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.autoCorrect.isDirty) {
+    view->setAutoCorrect(props.autoCorrect.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.autoCapitalize.isDirty) {
+    view->setAutoCapitalize(props.autoCapitalize.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.selectionColor.isDirty) {
+    view->setSelectionColor(props.selectionColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.prefixMarginRight.isDirty) {
+    view->setPrefixMarginRight(props.prefixMarginRight.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.suffixMarginLeft.isDirty) {
+    view->setSuffixMarginLeft(props.suffixMarginLeft.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onChangeText.isDirty) {
+    view->setOnChangeText(props.onChangeText.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onFocus.isDirty) {
+    view->setOnFocus(props.onFocus.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onBlur.isDirty) {
+    view->setOnBlur(props.onBlur.value);
+    // TODO: Set isDirty = false
+  }
+
+  // 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<JHybridAutoSizeInputSpec> shared = javaView->cthis()->shared_cast<JHybridAutoSizeInputSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::autosizeinput::views

package/nitrogen/generated/android/c++/views/JHybridAutoSizeInputStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridAutoSizeInputStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error autosizeinput was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#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 "JHybridAutoSizeInputSpec.hpp"
+#include "views/HybridAutoSizeInputComponent.hpp"
+
+namespace margelo::nitro::autosizeinput::views {
+
+using namespace facebook;
+
+class JHybridAutoSizeInputStateUpdater: public jni::JavaClass<JHybridAutoSizeInputStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/autosizeinput/views/HybridAutoSizeInputStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridAutoSizeInputSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridAutoSizeInputStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridAutoSizeInputComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::autosizeinput::views