@whetware/react-native-stroke-text 0.0.2

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

@@ -0,0 +1,84 @@
+///
+/// StrokeTextTransform.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::stroketext {
+
+  /**
+   * An enum which can be represented as a JavaScript union (StrokeTextTransform).
+   */
+  enum class StrokeTextTransform {
+    NONE      SWIFT_NAME(none) = 0,
+    UPPERCASE      SWIFT_NAME(uppercase) = 1,
+    LOWERCASE      SWIFT_NAME(lowercase) = 2,
+    CAPITALIZE      SWIFT_NAME(capitalize) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::stroketext
+
+namespace margelo::nitro {
+
+  // C++ StrokeTextTransform <> JS StrokeTextTransform (union)
+  template <>
+  struct JSIConverter<margelo::nitro::stroketext::StrokeTextTransform> final {
+    static inline margelo::nitro::stroketext::StrokeTextTransform fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::stroketext::StrokeTextTransform::NONE;
+        case hashString("uppercase"): return margelo::nitro::stroketext::StrokeTextTransform::UPPERCASE;
+        case hashString("lowercase"): return margelo::nitro::stroketext::StrokeTextTransform::LOWERCASE;
+        case hashString("capitalize"): return margelo::nitro::stroketext::StrokeTextTransform::CAPITALIZE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum StrokeTextTransform - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::stroketext::StrokeTextTransform arg) {
+      switch (arg) {
+        case margelo::nitro::stroketext::StrokeTextTransform::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::stroketext::StrokeTextTransform::UPPERCASE: return JSIConverter<std::string>::toJSI(runtime, "uppercase");
+        case margelo::nitro::stroketext::StrokeTextTransform::LOWERCASE: return JSIConverter<std::string>::toJSI(runtime, "lowercase");
+        case margelo::nitro::stroketext::StrokeTextTransform::CAPITALIZE: return JSIConverter<std::string>::toJSI(runtime, "capitalize");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert StrokeTextTransform to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("uppercase"):
+        case hashString("lowercase"):
+        case hashString("capitalize"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,388 @@
+///
+/// HybridStrokeTextViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStrokeTextViewComponent.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>
+
+namespace margelo::nitro::stroketext::views {
+
+  extern const char HybridStrokeTextViewComponentName[] = "StrokeTextView";
+
+  HybridStrokeTextViewProps::HybridStrokeTextViewProps(const react::PropsParserContext& context,
+                                                       const HybridStrokeTextViewProps& sourceProps,
+                                                       const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    text([&]() -> CachedProp<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::string>::fromRawValue(*runtime, value, sourceProps.text);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.text: ") + exc.what());
+      }
+    }()),
+    color([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("color", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.color;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.color);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.color: ") + exc.what());
+      }
+    }()),
+    strokeColor([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("strokeColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.strokeColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.strokeColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.strokeColor: ") + exc.what());
+      }
+    }()),
+    strokeWidth([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("strokeWidth", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.strokeWidth;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.strokeWidth);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.strokeWidth: ") + 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("StrokeTextView.fontSize: ") + 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("StrokeTextView.fontWeight: ") + 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("StrokeTextView.fontFamily: ") + exc.what());
+      }
+    }()),
+    fontStyle([&]() -> CachedProp<std::optional<StrokeTextFontStyle>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fontStyle", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fontStyle;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<StrokeTextFontStyle>>::fromRawValue(*runtime, value, sourceProps.fontStyle);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.fontStyle: ") + exc.what());
+      }
+    }()),
+    lineHeight([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("lineHeight", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.lineHeight;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.lineHeight);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.lineHeight: ") + exc.what());
+      }
+    }()),
+    letterSpacing([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("letterSpacing", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.letterSpacing;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.letterSpacing);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.letterSpacing: ") + exc.what());
+      }
+    }()),
+    textAlign([&]() -> CachedProp<std::optional<StrokeTextAlign>> {
+      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<StrokeTextAlign>>::fromRawValue(*runtime, value, sourceProps.textAlign);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.textAlign: ") + exc.what());
+      }
+    }()),
+    textDecorationLine([&]() -> CachedProp<std::optional<StrokeTextDecorationLine>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textDecorationLine", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textDecorationLine;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<StrokeTextDecorationLine>>::fromRawValue(*runtime, value, sourceProps.textDecorationLine);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.textDecorationLine: ") + exc.what());
+      }
+    }()),
+    textTransform([&]() -> CachedProp<std::optional<StrokeTextTransform>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textTransform", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textTransform;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<StrokeTextTransform>>::fromRawValue(*runtime, value, sourceProps.textTransform);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.textTransform: ") + exc.what());
+      }
+    }()),
+    opacity([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("opacity", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.opacity;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.opacity);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.opacity: ") + exc.what());
+      }
+    }()),
+    allowFontScaling([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("allowFontScaling", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.allowFontScaling;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.allowFontScaling);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.allowFontScaling: ") + exc.what());
+      }
+    }()),
+    maxFontSizeMultiplier([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxFontSizeMultiplier", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxFontSizeMultiplier;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxFontSizeMultiplier);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.maxFontSizeMultiplier: ") + exc.what());
+      }
+    }()),
+    includeFontPadding([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("includeFontPadding", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.includeFontPadding;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.includeFontPadding);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.includeFontPadding: ") + exc.what());
+      }
+    }()),
+    numberOfLines([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("numberOfLines", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.numberOfLines;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.numberOfLines);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.numberOfLines: ") + exc.what());
+      }
+    }()),
+    ellipsizeMode([&]() -> CachedProp<std::optional<StrokeTextEllipsizeMode>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("ellipsizeMode", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.ellipsizeMode;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<StrokeTextEllipsizeMode>>::fromRawValue(*runtime, value, sourceProps.ellipsizeMode);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.ellipsizeMode: ") + exc.what());
+      }
+    }()),
+    padding([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("padding", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.padding;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.padding);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.padding: ") + exc.what());
+      }
+    }()),
+    paddingVertical([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingVertical", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingVertical;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingVertical);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingVertical: ") + exc.what());
+      }
+    }()),
+    paddingHorizontal([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingHorizontal", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingHorizontal;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingHorizontal);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingHorizontal: ") + exc.what());
+      }
+    }()),
+    paddingTop([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingTop", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingTop;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingTop);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingTop: ") + exc.what());
+      }
+    }()),
+    paddingRight([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingRight", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingRight;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingRight);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingRight: ") + exc.what());
+      }
+    }()),
+    paddingBottom([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingBottom", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingBottom;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingBottom);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingBottom: ") + exc.what());
+      }
+    }()),
+    paddingLeft([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paddingLeft", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paddingLeft;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.paddingLeft);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("StrokeTextView.paddingLeft: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridStrokeTextViewSpec>& /* 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<HybridStrokeTextViewSpec>& /* 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("StrokeTextView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridStrokeTextViewProps::HybridStrokeTextViewProps(const HybridStrokeTextViewProps& other):
+    react::ViewProps(),
+    text(other.text),
+    color(other.color),
+    strokeColor(other.strokeColor),
+    strokeWidth(other.strokeWidth),
+    fontSize(other.fontSize),
+    fontWeight(other.fontWeight),
+    fontFamily(other.fontFamily),
+    fontStyle(other.fontStyle),
+    lineHeight(other.lineHeight),
+    letterSpacing(other.letterSpacing),
+    textAlign(other.textAlign),
+    textDecorationLine(other.textDecorationLine),
+    textTransform(other.textTransform),
+    opacity(other.opacity),
+    allowFontScaling(other.allowFontScaling),
+    maxFontSizeMultiplier(other.maxFontSizeMultiplier),
+    includeFontPadding(other.includeFontPadding),
+    numberOfLines(other.numberOfLines),
+    ellipsizeMode(other.ellipsizeMode),
+    padding(other.padding),
+    paddingVertical(other.paddingVertical),
+    paddingHorizontal(other.paddingHorizontal),
+    paddingTop(other.paddingTop),
+    paddingRight(other.paddingRight),
+    paddingBottom(other.paddingBottom),
+    paddingLeft(other.paddingLeft),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridStrokeTextViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("text"): return true;
+      case hashString("color"): return true;
+      case hashString("strokeColor"): return true;
+      case hashString("strokeWidth"): return true;
+      case hashString("fontSize"): return true;
+      case hashString("fontWeight"): return true;
+      case hashString("fontFamily"): return true;
+      case hashString("fontStyle"): return true;
+      case hashString("lineHeight"): return true;
+      case hashString("letterSpacing"): return true;
+      case hashString("textAlign"): return true;
+      case hashString("textDecorationLine"): return true;
+      case hashString("textTransform"): return true;
+      case hashString("opacity"): return true;
+      case hashString("allowFontScaling"): return true;
+      case hashString("maxFontSizeMultiplier"): return true;
+      case hashString("includeFontPadding"): return true;
+      case hashString("numberOfLines"): return true;
+      case hashString("ellipsizeMode"): return true;
+      case hashString("padding"): return true;
+      case hashString("paddingVertical"): return true;
+      case hashString("paddingHorizontal"): return true;
+      case hashString("paddingTop"): return true;
+      case hashString("paddingRight"): return true;
+      case hashString("paddingBottom"): return true;
+      case hashString("paddingLeft"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridStrokeTextViewComponentDescriptor::HybridStrokeTextViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridStrokeTextViewComponentDescriptor::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 HybridStrokeTextViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridStrokeTextViewComponentDescriptor::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<HybridStrokeTextViewShadowNode&>(shadowNode);
+    const HybridStrokeTextViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridStrokeTextViewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::stroketext::views

package/nitrogen/generated/shared/c++/views/HybridStrokeTextViewComponent.hpp

@@ -0,0 +1,138 @@
+///
+/// HybridStrokeTextViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include "StrokeTextFontStyle.hpp"
+#include "StrokeTextAlign.hpp"
+#include "StrokeTextDecorationLine.hpp"
+#include "StrokeTextTransform.hpp"
+#include "StrokeTextEllipsizeMode.hpp"
+#include <memory>
+#include "HybridStrokeTextViewSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::stroketext::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridStrokeTextViewComponentName[];
+
+  /**
+   * Props for the "StrokeTextView" View.
+   */
+  class HybridStrokeTextViewProps final: public react::ViewProps {
+  public:
+    HybridStrokeTextViewProps() = default;
+    HybridStrokeTextViewProps(const HybridStrokeTextViewProps&);
+    HybridStrokeTextViewProps(const react::PropsParserContext& context,
+                              const HybridStrokeTextViewProps& sourceProps,
+                              const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::string> text;
+    CachedProp<std::optional<std::string>> color;
+    CachedProp<std::optional<std::string>> strokeColor;
+    CachedProp<std::optional<double>> strokeWidth;
+    CachedProp<std::optional<double>> fontSize;
+    CachedProp<std::optional<std::string>> fontWeight;
+    CachedProp<std::optional<std::string>> fontFamily;
+    CachedProp<std::optional<StrokeTextFontStyle>> fontStyle;
+    CachedProp<std::optional<double>> lineHeight;
+    CachedProp<std::optional<double>> letterSpacing;
+    CachedProp<std::optional<StrokeTextAlign>> textAlign;
+    CachedProp<std::optional<StrokeTextDecorationLine>> textDecorationLine;
+    CachedProp<std::optional<StrokeTextTransform>> textTransform;
+    CachedProp<std::optional<double>> opacity;
+    CachedProp<std::optional<bool>> allowFontScaling;
+    CachedProp<std::optional<double>> maxFontSizeMultiplier;
+    CachedProp<std::optional<bool>> includeFontPadding;
+    CachedProp<std::optional<double>> numberOfLines;
+    CachedProp<std::optional<StrokeTextEllipsizeMode>> ellipsizeMode;
+    CachedProp<std::optional<double>> padding;
+    CachedProp<std::optional<double>> paddingVertical;
+    CachedProp<std::optional<double>> paddingHorizontal;
+    CachedProp<std::optional<double>> paddingTop;
+    CachedProp<std::optional<double>> paddingRight;
+    CachedProp<std::optional<double>> paddingBottom;
+    CachedProp<std::optional<double>> paddingLeft;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridStrokeTextViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "StrokeTextView" View.
+   */
+  class HybridStrokeTextViewState final {
+  public:
+    HybridStrokeTextViewState() = default;
+
+  public:
+    void setProps(const HybridStrokeTextViewProps& props) { _props.emplace(props); }
+    const std::optional<HybridStrokeTextViewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridStrokeTextViewState(const HybridStrokeTextViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridStrokeTextViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridStrokeTextViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridStrokeTextViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "StrokeTextView" View.
+   */
+  using HybridStrokeTextViewShadowNode = react::ConcreteViewShadowNode<HybridStrokeTextViewComponentName /* "HybridStrokeTextView" */,
+                                                                       HybridStrokeTextViewProps /* custom props */,
+                                                                       react::ViewEventEmitter /* default */,
+                                                                       HybridStrokeTextViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "StrokeTextView" View.
+   */
+  class HybridStrokeTextViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridStrokeTextViewShadowNode> {
+  public:
+    HybridStrokeTextViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridStrokeTextViewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "StrokeTextView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::stroketext::views

package/nitrogen/generated/shared/json/StrokeTextViewConfig.json

@@ -0,0 +1,35 @@
+{
+  "uiViewClassName": "StrokeTextView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "text": true,
+    "color": true,
+    "strokeColor": true,
+    "strokeWidth": true,
+    "fontSize": true,
+    "fontWeight": true,
+    "fontFamily": true,
+    "fontStyle": true,
+    "lineHeight": true,
+    "letterSpacing": true,
+    "textAlign": true,
+    "textDecorationLine": true,
+    "textTransform": true,
+    "opacity": true,
+    "allowFontScaling": true,
+    "maxFontSizeMultiplier": true,
+    "includeFontPadding": true,
+    "numberOfLines": true,
+    "ellipsizeMode": true,
+    "padding": true,
+    "paddingVertical": true,
+    "paddingHorizontal": true,
+    "paddingTop": true,
+    "paddingRight": true,
+    "paddingBottom": true,
+    "paddingLeft": true,
+    "hybridRef": true
+  }
+}