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

package/nitrogen/generated/shared/c++/HybridAutoSizeInputSpec.cpp

@@ -0,0 +1,74 @@
+///
+/// HybridAutoSizeInputSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAutoSizeInputSpec.hpp"
+
+namespace margelo::nitro::autosizeinput {
+
+  void HybridAutoSizeInputSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("text", &HybridAutoSizeInputSpec::getText);
+      prototype.registerHybridSetter("text", &HybridAutoSizeInputSpec::setText);
+      prototype.registerHybridGetter("prefix", &HybridAutoSizeInputSpec::getPrefix);
+      prototype.registerHybridSetter("prefix", &HybridAutoSizeInputSpec::setPrefix);
+      prototype.registerHybridGetter("suffix", &HybridAutoSizeInputSpec::getSuffix);
+      prototype.registerHybridSetter("suffix", &HybridAutoSizeInputSpec::setSuffix);
+      prototype.registerHybridGetter("placeholder", &HybridAutoSizeInputSpec::getPlaceholder);
+      prototype.registerHybridSetter("placeholder", &HybridAutoSizeInputSpec::setPlaceholder);
+      prototype.registerHybridGetter("fontSize", &HybridAutoSizeInputSpec::getFontSize);
+      prototype.registerHybridSetter("fontSize", &HybridAutoSizeInputSpec::setFontSize);
+      prototype.registerHybridGetter("minFontSize", &HybridAutoSizeInputSpec::getMinFontSize);
+      prototype.registerHybridSetter("minFontSize", &HybridAutoSizeInputSpec::setMinFontSize);
+      prototype.registerHybridGetter("multiline", &HybridAutoSizeInputSpec::getMultiline);
+      prototype.registerHybridSetter("multiline", &HybridAutoSizeInputSpec::setMultiline);
+      prototype.registerHybridGetter("maxNumberOfLines", &HybridAutoSizeInputSpec::getMaxNumberOfLines);
+      prototype.registerHybridSetter("maxNumberOfLines", &HybridAutoSizeInputSpec::setMaxNumberOfLines);
+      prototype.registerHybridGetter("textColor", &HybridAutoSizeInputSpec::getTextColor);
+      prototype.registerHybridSetter("textColor", &HybridAutoSizeInputSpec::setTextColor);
+      prototype.registerHybridGetter("prefixColor", &HybridAutoSizeInputSpec::getPrefixColor);
+      prototype.registerHybridSetter("prefixColor", &HybridAutoSizeInputSpec::setPrefixColor);
+      prototype.registerHybridGetter("suffixColor", &HybridAutoSizeInputSpec::getSuffixColor);
+      prototype.registerHybridSetter("suffixColor", &HybridAutoSizeInputSpec::setSuffixColor);
+      prototype.registerHybridGetter("placeholderColor", &HybridAutoSizeInputSpec::getPlaceholderColor);
+      prototype.registerHybridSetter("placeholderColor", &HybridAutoSizeInputSpec::setPlaceholderColor);
+      prototype.registerHybridGetter("textAlign", &HybridAutoSizeInputSpec::getTextAlign);
+      prototype.registerHybridSetter("textAlign", &HybridAutoSizeInputSpec::setTextAlign);
+      prototype.registerHybridGetter("fontFamily", &HybridAutoSizeInputSpec::getFontFamily);
+      prototype.registerHybridSetter("fontFamily", &HybridAutoSizeInputSpec::setFontFamily);
+      prototype.registerHybridGetter("fontWeight", &HybridAutoSizeInputSpec::getFontWeight);
+      prototype.registerHybridSetter("fontWeight", &HybridAutoSizeInputSpec::setFontWeight);
+      prototype.registerHybridGetter("editable", &HybridAutoSizeInputSpec::getEditable);
+      prototype.registerHybridSetter("editable", &HybridAutoSizeInputSpec::setEditable);
+      prototype.registerHybridGetter("keyboardType", &HybridAutoSizeInputSpec::getKeyboardType);
+      prototype.registerHybridSetter("keyboardType", &HybridAutoSizeInputSpec::setKeyboardType);
+      prototype.registerHybridGetter("returnKeyType", &HybridAutoSizeInputSpec::getReturnKeyType);
+      prototype.registerHybridSetter("returnKeyType", &HybridAutoSizeInputSpec::setReturnKeyType);
+      prototype.registerHybridGetter("autoCorrect", &HybridAutoSizeInputSpec::getAutoCorrect);
+      prototype.registerHybridSetter("autoCorrect", &HybridAutoSizeInputSpec::setAutoCorrect);
+      prototype.registerHybridGetter("autoCapitalize", &HybridAutoSizeInputSpec::getAutoCapitalize);
+      prototype.registerHybridSetter("autoCapitalize", &HybridAutoSizeInputSpec::setAutoCapitalize);
+      prototype.registerHybridGetter("selectionColor", &HybridAutoSizeInputSpec::getSelectionColor);
+      prototype.registerHybridSetter("selectionColor", &HybridAutoSizeInputSpec::setSelectionColor);
+      prototype.registerHybridGetter("prefixMarginRight", &HybridAutoSizeInputSpec::getPrefixMarginRight);
+      prototype.registerHybridSetter("prefixMarginRight", &HybridAutoSizeInputSpec::setPrefixMarginRight);
+      prototype.registerHybridGetter("suffixMarginLeft", &HybridAutoSizeInputSpec::getSuffixMarginLeft);
+      prototype.registerHybridSetter("suffixMarginLeft", &HybridAutoSizeInputSpec::setSuffixMarginLeft);
+      prototype.registerHybridGetter("onChangeText", &HybridAutoSizeInputSpec::getOnChangeText);
+      prototype.registerHybridSetter("onChangeText", &HybridAutoSizeInputSpec::setOnChangeText);
+      prototype.registerHybridGetter("onFocus", &HybridAutoSizeInputSpec::getOnFocus);
+      prototype.registerHybridSetter("onFocus", &HybridAutoSizeInputSpec::setOnFocus);
+      prototype.registerHybridGetter("onBlur", &HybridAutoSizeInputSpec::getOnBlur);
+      prototype.registerHybridSetter("onBlur", &HybridAutoSizeInputSpec::setOnBlur);
+      prototype.registerHybridMethod("focus", &HybridAutoSizeInputSpec::focus);
+      prototype.registerHybridMethod("blur", &HybridAutoSizeInputSpec::blur);
+    });
+  }
+
+} // namespace margelo::nitro::autosizeinput

package/nitrogen/generated/shared/c++/HybridAutoSizeInputSpec.hpp

@@ -0,0 +1,116 @@
+///
+/// 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
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <functional>
+
+namespace margelo::nitro::autosizeinput {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AutoSizeInput`
+   * Inherit this class to create instances of `HybridAutoSizeInputSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAutoSizeInput: public HybridAutoSizeInputSpec {
+   * public:
+   *   HybridAutoSizeInput(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAutoSizeInputSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAutoSizeInputSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAutoSizeInputSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::string> getText() = 0;
+      virtual void setText(const std::optional<std::string>& text) = 0;
+      virtual std::optional<std::string> getPrefix() = 0;
+      virtual void setPrefix(const std::optional<std::string>& prefix) = 0;
+      virtual std::optional<std::string> getSuffix() = 0;
+      virtual void setSuffix(const std::optional<std::string>& suffix) = 0;
+      virtual std::optional<std::string> getPlaceholder() = 0;
+      virtual void setPlaceholder(const std::optional<std::string>& placeholder) = 0;
+      virtual std::optional<double> getFontSize() = 0;
+      virtual void setFontSize(std::optional<double> fontSize) = 0;
+      virtual std::optional<double> getMinFontSize() = 0;
+      virtual void setMinFontSize(std::optional<double> minFontSize) = 0;
+      virtual std::optional<bool> getMultiline() = 0;
+      virtual void setMultiline(std::optional<bool> multiline) = 0;
+      virtual std::optional<double> getMaxNumberOfLines() = 0;
+      virtual void setMaxNumberOfLines(std::optional<double> maxNumberOfLines) = 0;
+      virtual std::optional<std::string> getTextColor() = 0;
+      virtual void setTextColor(const std::optional<std::string>& textColor) = 0;
+      virtual std::optional<std::string> getPrefixColor() = 0;
+      virtual void setPrefixColor(const std::optional<std::string>& prefixColor) = 0;
+      virtual std::optional<std::string> getSuffixColor() = 0;
+      virtual void setSuffixColor(const std::optional<std::string>& suffixColor) = 0;
+      virtual std::optional<std::string> getPlaceholderColor() = 0;
+      virtual void setPlaceholderColor(const std::optional<std::string>& placeholderColor) = 0;
+      virtual std::optional<std::string> getTextAlign() = 0;
+      virtual void setTextAlign(const std::optional<std::string>& textAlign) = 0;
+      virtual std::optional<std::string> getFontFamily() = 0;
+      virtual void setFontFamily(const std::optional<std::string>& fontFamily) = 0;
+      virtual std::optional<std::string> getFontWeight() = 0;
+      virtual void setFontWeight(const std::optional<std::string>& fontWeight) = 0;
+      virtual std::optional<bool> getEditable() = 0;
+      virtual void setEditable(std::optional<bool> editable) = 0;
+      virtual std::optional<std::string> getKeyboardType() = 0;
+      virtual void setKeyboardType(const std::optional<std::string>& keyboardType) = 0;
+      virtual std::optional<std::string> getReturnKeyType() = 0;
+      virtual void setReturnKeyType(const std::optional<std::string>& returnKeyType) = 0;
+      virtual std::optional<bool> getAutoCorrect() = 0;
+      virtual void setAutoCorrect(std::optional<bool> autoCorrect) = 0;
+      virtual std::optional<std::string> getAutoCapitalize() = 0;
+      virtual void setAutoCapitalize(const std::optional<std::string>& autoCapitalize) = 0;
+      virtual std::optional<std::string> getSelectionColor() = 0;
+      virtual void setSelectionColor(const std::optional<std::string>& selectionColor) = 0;
+      virtual std::optional<double> getPrefixMarginRight() = 0;
+      virtual void setPrefixMarginRight(std::optional<double> prefixMarginRight) = 0;
+      virtual std::optional<double> getSuffixMarginLeft() = 0;
+      virtual void setSuffixMarginLeft(std::optional<double> suffixMarginLeft) = 0;
+      virtual std::optional<std::function<void(const std::string& /* text */)>> getOnChangeText() = 0;
+      virtual void setOnChangeText(const std::optional<std::function<void(const std::string& /* text */)>>& onChangeText) = 0;
+      virtual std::optional<std::function<void()>> getOnFocus() = 0;
+      virtual void setOnFocus(const std::optional<std::function<void()>>& onFocus) = 0;
+      virtual std::optional<std::function<void()>> getOnBlur() = 0;
+      virtual void setOnBlur(const std::optional<std::function<void()>>& onBlur) = 0;
+
+    public:
+      // Methods
+      virtual void focus() = 0;
+      virtual void blur() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AutoSizeInput";
+  };
+
+} // namespace margelo::nitro::autosizeinput

package/nitrogen/generated/shared/c++/views/HybridAutoSizeInputComponent.cpp

@@ -0,0 +1,387 @@
+///
+/// HybridAutoSizeInputComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAutoSizeInputComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::autosizeinput::views {
+
+  extern const char HybridAutoSizeInputComponentName[] = "AutoSizeInput";
+
+  HybridAutoSizeInputProps::HybridAutoSizeInputProps(const react::PropsParserContext& context,
+                                                     const HybridAutoSizeInputProps& sourceProps,
+                                                     const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    text([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("text", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.text;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.text);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.text: ") + exc.what());
+      }
+    }()),
+    prefix([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("prefix", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.prefix;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.prefix);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.prefix: ") + exc.what());
+      }
+    }()),
+    suffix([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("suffix", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.suffix;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.suffix);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.suffix: ") + exc.what());
+      }
+    }()),
+    placeholder([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("placeholder", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.placeholder;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.placeholder);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.placeholder: ") + exc.what());
+      }
+    }()),
+    fontSize([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.fontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.fontSize: ") + exc.what());
+      }
+    }()),
+    minFontSize([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("minFontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.minFontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.minFontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.minFontSize: ") + exc.what());
+      }
+    }()),
+    multiline([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("multiline", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.multiline;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.multiline);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.multiline: ") + exc.what());
+      }
+    }()),
+    maxNumberOfLines([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxNumberOfLines", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxNumberOfLines;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxNumberOfLines);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.maxNumberOfLines: ") + exc.what());
+      }
+    }()),
+    textColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.textColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.textColor: ") + exc.what());
+      }
+    }()),
+    prefixColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("prefixColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.prefixColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.prefixColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.prefixColor: ") + exc.what());
+      }
+    }()),
+    suffixColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("suffixColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.suffixColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.suffixColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.suffixColor: ") + exc.what());
+      }
+    }()),
+    placeholderColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("placeholderColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.placeholderColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.placeholderColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.placeholderColor: ") + exc.what());
+      }
+    }()),
+    textAlign([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textAlign", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textAlign;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.textAlign);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.textAlign: ") + exc.what());
+      }
+    }()),
+    fontFamily([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fontFamily", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fontFamily;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.fontFamily);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.fontFamily: ") + exc.what());
+      }
+    }()),
+    fontWeight([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fontWeight", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fontWeight;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.fontWeight);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.fontWeight: ") + exc.what());
+      }
+    }()),
+    editable([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("editable", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.editable;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.editable);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.editable: ") + exc.what());
+      }
+    }()),
+    keyboardType([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("keyboardType", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.keyboardType;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.keyboardType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.keyboardType: ") + exc.what());
+      }
+    }()),
+    returnKeyType([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("returnKeyType", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.returnKeyType;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.returnKeyType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.returnKeyType: ") + exc.what());
+      }
+    }()),
+    autoCorrect([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("autoCorrect", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.autoCorrect;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.autoCorrect);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.autoCorrect: ") + exc.what());
+      }
+    }()),
+    autoCapitalize([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("autoCapitalize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.autoCapitalize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.autoCapitalize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.autoCapitalize: ") + exc.what());
+      }
+    }()),
+    selectionColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("selectionColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.selectionColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.selectionColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.selectionColor: ") + exc.what());
+      }
+    }()),
+    prefixMarginRight([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("prefixMarginRight", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.prefixMarginRight;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.prefixMarginRight);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.prefixMarginRight: ") + exc.what());
+      }
+    }()),
+    suffixMarginLeft([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("suffixMarginLeft", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.suffixMarginLeft;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.suffixMarginLeft);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.suffixMarginLeft: ") + exc.what());
+      }
+    }()),
+    onChangeText([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* text */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onChangeText", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onChangeText;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* text */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onChangeText);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.onChangeText: ") + exc.what());
+      }
+    }()),
+    onFocus([&]() -> CachedProp<std::optional<std::function<void()>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onFocus", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onFocus;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void()>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onFocus);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.onFocus: ") + exc.what());
+      }
+    }()),
+    onBlur([&]() -> CachedProp<std::optional<std::function<void()>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onBlur", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onBlur;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void()>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onBlur);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.onBlur: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAutoSizeInputSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAutoSizeInputSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AutoSizeInput.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAutoSizeInputProps::HybridAutoSizeInputProps(const HybridAutoSizeInputProps& other):
+    react::ViewProps(),
+    text(other.text),
+    prefix(other.prefix),
+    suffix(other.suffix),
+    placeholder(other.placeholder),
+    fontSize(other.fontSize),
+    minFontSize(other.minFontSize),
+    multiline(other.multiline),
+    maxNumberOfLines(other.maxNumberOfLines),
+    textColor(other.textColor),
+    prefixColor(other.prefixColor),
+    suffixColor(other.suffixColor),
+    placeholderColor(other.placeholderColor),
+    textAlign(other.textAlign),
+    fontFamily(other.fontFamily),
+    fontWeight(other.fontWeight),
+    editable(other.editable),
+    keyboardType(other.keyboardType),
+    returnKeyType(other.returnKeyType),
+    autoCorrect(other.autoCorrect),
+    autoCapitalize(other.autoCapitalize),
+    selectionColor(other.selectionColor),
+    prefixMarginRight(other.prefixMarginRight),
+    suffixMarginLeft(other.suffixMarginLeft),
+    onChangeText(other.onChangeText),
+    onFocus(other.onFocus),
+    onBlur(other.onBlur),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAutoSizeInputProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("text"): return true;
+      case hashString("prefix"): return true;
+      case hashString("suffix"): return true;
+      case hashString("placeholder"): return true;
+      case hashString("fontSize"): return true;
+      case hashString("minFontSize"): return true;
+      case hashString("multiline"): return true;
+      case hashString("maxNumberOfLines"): return true;
+      case hashString("textColor"): return true;
+      case hashString("prefixColor"): return true;
+      case hashString("suffixColor"): return true;
+      case hashString("placeholderColor"): return true;
+      case hashString("textAlign"): return true;
+      case hashString("fontFamily"): return true;
+      case hashString("fontWeight"): return true;
+      case hashString("editable"): return true;
+      case hashString("keyboardType"): return true;
+      case hashString("returnKeyType"): return true;
+      case hashString("autoCorrect"): return true;
+      case hashString("autoCapitalize"): return true;
+      case hashString("selectionColor"): return true;
+      case hashString("prefixMarginRight"): return true;
+      case hashString("suffixMarginLeft"): return true;
+      case hashString("onChangeText"): return true;
+      case hashString("onFocus"): return true;
+      case hashString("onBlur"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAutoSizeInputComponentDescriptor::HybridAutoSizeInputComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAutoSizeInputComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                         const std::shared_ptr<const react::Props>& props,
+                                                                                         react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridAutoSizeInputShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAutoSizeInputComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<HybridAutoSizeInputShadowNode&>(shadowNode);
+    const HybridAutoSizeInputProps& props = concreteShadowNode.getConcreteProps();
+    HybridAutoSizeInputState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::autosizeinput::views