@onekeyfe/react-native-auto-size-input 3.0.95 → 3.0.98

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

@@ -7,345 +7,51 @@
 
 #include "HybridAutoSizeInputComponent.hpp"
 
-#include <string>
-#include <exception>
-#include <utility>
-#include <NitroModules/NitroDefines.hpp>
-#include <NitroModules/JSIConverter.hpp>
-#include <NitroModules/PropNameIDCache.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>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/ReactProp.hpp>
 
 namespace margelo::nitro::autosizeinput::views {
 
+  using namespace facebook;
+
   extern const char HybridAutoSizeInputComponentName[] = "AutoSizeInput";
 
   HybridAutoSizeInputProps::HybridAutoSizeInputProps(const react::PropsParserContext& context,
                                                      const HybridAutoSizeInputProps& sourceProps,
                                                      const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    mostRecentEventCount([&]() -> CachedProp<std::optional<double>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("mostRecentEventCount", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.mostRecentEventCount;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.mostRecentEventCount);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.mostRecentEventCount: ") + exc.what());
-      }
-    }()),
-    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());
-      }
-    }()),
-    showBorder([&]() -> CachedProp<std::optional<bool>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("showBorder", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.showBorder;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showBorder);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.showBorder: ") + exc.what());
-      }
-    }()),
-    inputBackgroundColor([&]() -> CachedProp<std::optional<std::string>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("inputBackgroundColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.inputBackgroundColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.inputBackgroundColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.inputBackgroundColor: ") + exc.what());
-      }
-    }()),
-    contentAutoWidth([&]() -> CachedProp<std::optional<bool>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("contentAutoWidth", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.contentAutoWidth;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.contentAutoWidth);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.contentAutoWidth: ") + exc.what());
-      }
-    }()),
-    contentCentered([&]() -> CachedProp<std::optional<bool>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("contentCentered", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.contentCentered;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.contentCentered);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.contentCentered: ") + 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, PropNameIDCache::get(*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, PropNameIDCache::get(*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, PropNameIDCache::get(*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, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("AutoSizeInput.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    mostRecentEventCount(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "mostRecentEventCount", rawProps, sourceProps.mostRecentEventCount)),
+    text(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "text", rawProps, sourceProps.text)),
+    prefix(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "prefix", rawProps, sourceProps.prefix)),
+    suffix(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "suffix", rawProps, sourceProps.suffix)),
+    placeholder(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "placeholder", rawProps, sourceProps.placeholder)),
+    fontSize(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "fontSize", rawProps, sourceProps.fontSize)),
+    minFontSize(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "minFontSize", rawProps, sourceProps.minFontSize)),
+    multiline(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "multiline", rawProps, sourceProps.multiline)),
+    maxNumberOfLines(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "maxNumberOfLines", rawProps, sourceProps.maxNumberOfLines)),
+    textColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "textColor", rawProps, sourceProps.textColor)),
+    prefixColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "prefixColor", rawProps, sourceProps.prefixColor)),
+    suffixColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "suffixColor", rawProps, sourceProps.suffixColor)),
+    placeholderColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "placeholderColor", rawProps, sourceProps.placeholderColor)),
+    textAlign(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "textAlign", rawProps, sourceProps.textAlign)),
+    fontFamily(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "fontFamily", rawProps, sourceProps.fontFamily)),
+    fontWeight(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "fontWeight", rawProps, sourceProps.fontWeight)),
+    editable(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "editable", rawProps, sourceProps.editable)),
+    keyboardType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "keyboardType", rawProps, sourceProps.keyboardType)),
+    returnKeyType(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "returnKeyType", rawProps, sourceProps.returnKeyType)),
+    autoCorrect(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "autoCorrect", rawProps, sourceProps.autoCorrect)),
+    autoCapitalize(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "autoCapitalize", rawProps, sourceProps.autoCapitalize)),
+    selectionColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "selectionColor", rawProps, sourceProps.selectionColor)),
+    prefixMarginRight(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "prefixMarginRight", rawProps, sourceProps.prefixMarginRight)),
+    suffixMarginLeft(nitro::ReactProp<std::optional<double>>::fromRawValue("AutoSizeInput", "suffixMarginLeft", rawProps, sourceProps.suffixMarginLeft)),
+    showBorder(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "showBorder", rawProps, sourceProps.showBorder)),
+    inputBackgroundColor(nitro::ReactProp<std::optional<std::string>>::fromRawValue("AutoSizeInput", "inputBackgroundColor", rawProps, sourceProps.inputBackgroundColor)),
+    contentAutoWidth(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "contentAutoWidth", rawProps, sourceProps.contentAutoWidth)),
+    contentCentered(nitro::ReactProp<std::optional<bool>>::fromRawValue("AutoSizeInput", "contentCentered", rawProps, sourceProps.contentCentered)),
+    onChangeText(nitro::ReactProp<std::optional<std::function<void(const std::string& /* text */)>>>::fromRawValue("AutoSizeInput", "onChangeText", rawProps, sourceProps.onChangeText)),
+    onFocus(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("AutoSizeInput", "onFocus", rawProps, sourceProps.onFocus)),
+    onBlur(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("AutoSizeInput", "onBlur", rawProps, sourceProps.onBlur)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridAutoSizeInputSpec>& /* ref */)>>>::fromRawValue("AutoSizeInput", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridAutoSizeInputProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -385,29 +91,4 @@ namespace margelo::nitro::autosizeinput::views {
     }
   }
 
-  HybridAutoSizeInputComponentDescriptor::HybridAutoSizeInputComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  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 = static_cast<HybridAutoSizeInputShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridAutoSizeInputProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridAutoSizeInputProps>& props = std::const_pointer_cast<HybridAutoSizeInputProps>(constProps);
-    HybridAutoSizeInputState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::autosizeinput::views

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

@@ -7,14 +7,15 @@
 
 #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 <NitroModules/ReactProp.hpp>
+#include <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
 
 #include <optional>
 #include <string>
@@ -42,38 +43,110 @@ namespace margelo::nitro::autosizeinput::views {
                              const react::RawProps& rawProps);
 
   public:
-    CachedProp<std::optional<double>> mostRecentEventCount;
-    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<bool>> showBorder;
-    CachedProp<std::optional<std::string>> inputBackgroundColor;
-    CachedProp<std::optional<bool>> contentAutoWidth;
-    CachedProp<std::optional<bool>> contentCentered;
-    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;
+    nitro::ReactProp<std::optional<double>> mostRecentEventCount;
+    nitro::ReactProp<std::optional<std::string>> text;
+    nitro::ReactProp<std::optional<std::string>> prefix;
+    nitro::ReactProp<std::optional<std::string>> suffix;
+    nitro::ReactProp<std::optional<std::string>> placeholder;
+    nitro::ReactProp<std::optional<double>> fontSize;
+    nitro::ReactProp<std::optional<double>> minFontSize;
+    nitro::ReactProp<std::optional<bool>> multiline;
+    nitro::ReactProp<std::optional<double>> maxNumberOfLines;
+    nitro::ReactProp<std::optional<std::string>> textColor;
+    nitro::ReactProp<std::optional<std::string>> prefixColor;
+    nitro::ReactProp<std::optional<std::string>> suffixColor;
+    nitro::ReactProp<std::optional<std::string>> placeholderColor;
+    nitro::ReactProp<std::optional<std::string>> textAlign;
+    nitro::ReactProp<std::optional<std::string>> fontFamily;
+    nitro::ReactProp<std::optional<std::string>> fontWeight;
+    nitro::ReactProp<std::optional<bool>> editable;
+    nitro::ReactProp<std::optional<std::string>> keyboardType;
+    nitro::ReactProp<std::optional<std::string>> returnKeyType;
+    nitro::ReactProp<std::optional<bool>> autoCorrect;
+    nitro::ReactProp<std::optional<std::string>> autoCapitalize;
+    nitro::ReactProp<std::optional<std::string>> selectionColor;
+    nitro::ReactProp<std::optional<double>> prefixMarginRight;
+    nitro::ReactProp<std::optional<double>> suffixMarginLeft;
+    nitro::ReactProp<std::optional<bool>> showBorder;
+    nitro::ReactProp<std::optional<std::string>> inputBackgroundColor;
+    nitro::ReactProp<std::optional<bool>> contentAutoWidth;
+    nitro::ReactProp<std::optional<bool>> contentCentered;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* text */)>>> onChangeText;
+    nitro::ReactProp<std::optional<std::function<void()>>> onFocus;
+    nitro::ReactProp<std::optional<std::function<void()>>> onBlur;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridAutoSizeInputSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridAutoSizeInputProps& other) const noexcept {
+      return mostRecentEventCount.hasSameValue(other.mostRecentEventCount) &&
+             text.hasSameValue(other.text) &&
+             prefix.hasSameValue(other.prefix) &&
+             suffix.hasSameValue(other.suffix) &&
+             placeholder.hasSameValue(other.placeholder) &&
+             fontSize.hasSameValue(other.fontSize) &&
+             minFontSize.hasSameValue(other.minFontSize) &&
+             multiline.hasSameValue(other.multiline) &&
+             maxNumberOfLines.hasSameValue(other.maxNumberOfLines) &&
+             textColor.hasSameValue(other.textColor) &&
+             prefixColor.hasSameValue(other.prefixColor) &&
+             suffixColor.hasSameValue(other.suffixColor) &&
+             placeholderColor.hasSameValue(other.placeholderColor) &&
+             textAlign.hasSameValue(other.textAlign) &&
+             fontFamily.hasSameValue(other.fontFamily) &&
+             fontWeight.hasSameValue(other.fontWeight) &&
+             editable.hasSameValue(other.editable) &&
+             keyboardType.hasSameValue(other.keyboardType) &&
+             returnKeyType.hasSameValue(other.returnKeyType) &&
+             autoCorrect.hasSameValue(other.autoCorrect) &&
+             autoCapitalize.hasSameValue(other.autoCapitalize) &&
+             selectionColor.hasSameValue(other.selectionColor) &&
+             prefixMarginRight.hasSameValue(other.prefixMarginRight) &&
+             suffixMarginLeft.hasSameValue(other.suffixMarginLeft) &&
+             showBorder.hasSameValue(other.showBorder) &&
+             inputBackgroundColor.hasSameValue(other.inputBackgroundColor) &&
+             contentAutoWidth.hasSameValue(other.contentAutoWidth) &&
+             contentCentered.hasSameValue(other.contentCentered) &&
+             onChangeText.hasSameValue(other.onChangeText) &&
+             onFocus.hasSameValue(other.onFocus) &&
+             onBlur.hasSameValue(other.onBlur) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return mostRecentEventCount.isProvided() ||
+             text.isProvided() ||
+             prefix.isProvided() ||
+             suffix.isProvided() ||
+             placeholder.isProvided() ||
+             fontSize.isProvided() ||
+             minFontSize.isProvided() ||
+             multiline.isProvided() ||
+             maxNumberOfLines.isProvided() ||
+             textColor.isProvided() ||
+             prefixColor.isProvided() ||
+             suffixColor.isProvided() ||
+             placeholderColor.isProvided() ||
+             textAlign.isProvided() ||
+             fontFamily.isProvided() ||
+             fontWeight.isProvided() ||
+             editable.isProvided() ||
+             keyboardType.isProvided() ||
+             returnKeyType.isProvided() ||
+             autoCorrect.isProvided() ||
+             autoCapitalize.isProvided() ||
+             selectionColor.isProvided() ||
+             prefixMarginRight.isProvided() ||
+             suffixMarginLeft.isProvided() ||
+             showBorder.isProvided() ||
+             inputBackgroundColor.isProvided() ||
+             contentAutoWidth.isProvided() ||
+             contentCentered.isProvided() ||
+             onChangeText.isProvided() ||
+             onFocus.isProvided() ||
+             onBlur.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -82,32 +155,7 @@ namespace margelo::nitro::autosizeinput::views {
   /**
    * State for the "AutoSizeInput" View.
    */
-  class HybridAutoSizeInputState final {
-  public:
-    HybridAutoSizeInputState() = default;
-    explicit HybridAutoSizeInputState(const std::shared_ptr<HybridAutoSizeInputProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<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::shared_ptr<HybridAutoSizeInputProps> _props;
-  };
+  using HybridAutoSizeInputState = nitro::ViewPropsHolderState<HybridAutoSizeInputProps>;
 
   /**
    * The Shadow Node for the "AutoSizeInput" View.
@@ -120,21 +168,7 @@ namespace margelo::nitro::autosizeinput::views {
   /**
    * The Component Descriptor for the "AutoSizeInput" View.
    */
-  class HybridAutoSizeInputComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAutoSizeInputShadowNode> {
-  public:
-    explicit 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
-  };
+  using HybridAutoSizeInputComponentDescriptor = nitro::ViewComponentDescriptor<HybridAutoSizeInputShadowNode>;
 
   /* The actual view for "AutoSizeInput" needs to be implemented in platform-specific code. */