@whetware/react-native-stroke-text 0.0.12 → 0.0.15

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @whetware/react-native-stroke-text
 
+## 0.0.15
+
+### Patch Changes
+
+- [`57b743f`](https://github.com/whetware/react-native-stroke-text/commit/57b743f53c5ef6777be9564d38d2d95c5facb13b) Thanks [@evelant](https://github.com/evelant)! - Keep the native `textTransform` prop concrete during Android measured-line updates so Fabric never sends Nitro a null enum value.
+
+## 0.0.13
+
+### Patch Changes
+
+- [`f94116e`](https://github.com/whetware/react-native-stroke-text/commit/f94116e693d2ee77e643d952f6943728e9d52c25) Thanks [@evelant](https://github.com/evelant)! - Fix Android stroke-text wrapping by measuring the outline inset as part of layout, drawing the RN-measured line breaks in the native overlay, aligning native text metrics with React Native Text, and preserving separate fill and outline colors.
+
+  Regenerate Nitro native bindings with Nitro/Nitrogen 0.36.1 so the Android C++ and Kotlin code builds with React Native 0.86 / Expo 57, including fbjni's current `HybridClass` requirements.
+
 ## 0.0.6
 
 ### Patch Changes

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,6 +1,9 @@
 #include <jni.h>
+#include <fbjni/fbjni.h>
 #include "NitroStrokeTextOnLoad.hpp"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return margelo::nitro::stroketext::initialize(vm);
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::stroketext::registerAllNatives();
+  });
 }

package/android/src/main/java/com/margelo/nitro/stroketext/HybridStrokeTextView.kt

@@ -1,8 +1,8 @@
 package com.margelo.nitro.stroketext
 
 import android.view.View
-import com.facebook.jni.HybridData
 import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.R.id.associated_hybrid_view_tag
 import kotlin.math.ceil
 
 class HybridStrokeTextView(context: ThemedReactContext) : HybridStrokeTextViewSpec() {
@@ -43,17 +43,11 @@ class HybridStrokeTextView(context: ThemedReactContext) : HybridStrokeTextViewSp
     if (isDisposed) return
     isDisposed = true
     super.dispose()
+  }
 
-    try {
-      val hybridDataField = HybridStrokeTextViewSpec::class.java.getDeclaredField("mHybridData")
-      hybridDataField.isAccessible = true
-      val hybridData = hybridDataField.get(this) as? HybridData ?: return
-
-      val resetNativeMethod = HybridData::class.java.getDeclaredMethod("resetNative")
-      resetNativeMethod.isAccessible = true
-      resetNativeMethod.invoke(hybridData)
-    } catch (_: Throwable) {
-    }
+  override fun onDropView() {
+    strokeTextView.setTag(associated_hybrid_view_tag, null)
+    dispose()
   }
 
   override fun afterUpdate() {

package/android/src/main/java/com/margelo/nitro/stroketext/NitroStrokeTextPackage.kt

@@ -7,12 +7,12 @@ import com.facebook.react.BaseReactPackage
 import com.facebook.react.ViewManagerOnDemandReactPackage
 import com.facebook.react.bridge.ModuleSpec
 import com.facebook.react.uimanager.ViewManager
-import com.margelo.nitro.stroketext.views.StrokeTextViewManager
+import com.margelo.nitro.stroketext.views.HybridStrokeTextViewManager
 
 class NitroStrokeTextPackage : BaseReactPackage(), ViewManagerOnDemandReactPackage {
     private val viewManagers: Map<String, ModuleSpec> by lazy {
         mapOf(
-            "StrokeTextView" to ModuleSpec.viewManagerSpec { StrokeTextViewManager() }
+            "StrokeTextView" to ModuleSpec.viewManagerSpec { HybridStrokeTextViewManager() }
         )
     }
 

package/lib/StrokeText.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { Platform, StyleSheet, Text, View } from 'react-native';
 import { callback, getHostComponent } from 'react-native-nitro-modules';
 import StrokeTextViewConfig from '../nitrogen/generated/shared/json/StrokeTextViewConfig.json';
+import { resolveNativeTextTransform } from './resolveNativeTextTransform';
 const NativeStrokeTextView = getHostComponent('StrokeTextView', () => StrokeTextViewConfig);
 function resolveText(text, children) {
     if (typeof text === 'string')
@@ -113,7 +114,7 @@ export function StrokeText({ text, children, style, hybridRef, ...rest }) {
     const shouldSyncMeasuredLineBreaks = Platform.OS === 'android' && effectiveNumberOfLines == null;
     const [measuredNativeText, setMeasuredNativeText] = React.useState(undefined);
     const nativeText = measuredNativeText ?? resolvedText;
-    const nativeTextTransform = measuredNativeText == null ? effectiveTextTransform : 'none';
+    const nativeTextTransform = resolveNativeTextTransform(effectiveTextTransform, measuredNativeText != null);
     // RN's hidden Text owns measurement, but Android TextView gets its own layout pass.
     // Compensate for the native stroke inset on every edge, then give that native
     // pass extra right-side room so one-pixel/font-metric drift cannot turn an RN

package/lib/resolveNativeTextTransform.d.ts

@@ -0,0 +1,7 @@
+import type { StrokeTextTransform } from './specs/StrokeTextView.nitro';
+/**
+ * Keep the Fabric host prop concrete across text-measurement state changes.
+ * React Native represents a removed prop as null during native updates, while
+ * Nitro's optional enum converter accepts undefined but rejects null.
+ */
+export declare function resolveNativeTextTransform(effectiveTextTransform: StrokeTextTransform | undefined, hasMeasuredNativeText: boolean): StrokeTextTransform;

package/lib/resolveNativeTextTransform.js

@@ -0,0 +1,8 @@
+/**
+ * Keep the Fabric host prop concrete across text-measurement state changes.
+ * React Native represents a removed prop as null during native updates, while
+ * Nitro's optional enum converter accepts undefined but rejects null.
+ */
+export function resolveNativeTextTransform(effectiveTextTransform, hasMeasuredNativeText) {
+    return hasMeasuredNativeText ? 'none' : (effectiveTextTransform ?? 'none');
+}

package/nitro.json

@@ -14,8 +14,14 @@
   },
   "autolinking": {
     "StrokeTextView": {
-      "swift": "HybridStrokeTextView",
-      "kotlin": "HybridStrokeTextView"
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridStrokeTextView"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridStrokeTextView"
+      }
     }
   },
   "ignorePaths": [

package/nitrogen/generated/android/NitroStrokeTextOnLoad.cpp

@@ -22,25 +22,35 @@
 namespace margelo::nitro::stroketext {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::stroketext::registerAllNatives();
+  });
+}
+
+struct JHybridStrokeTextViewSpecImpl: public jni::JavaClass<JHybridStrokeTextViewSpecImpl, JHybridStrokeTextViewSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/stroketext/HybridStrokeTextView;";
+  static std::shared_ptr<JHybridStrokeTextViewSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridStrokeTextViewSpecImpl::javaobject()>();
+    jni::local_ref<JHybridStrokeTextViewSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridStrokeTextViewSpec();
+  }
+};
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::stroketext;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::stroketext::JHybridStrokeTextViewSpec::registerNatives();
-    margelo::nitro::stroketext::views::JHybridStrokeTextViewStateUpdater::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "StrokeTextView",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridStrokeTextViewSpec::javaobject> object("com/margelo/nitro/stroketext/HybridStrokeTextView");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::stroketext::JHybridStrokeTextViewSpec::CxxPart::registerNatives();
+  margelo::nitro::stroketext::views::JHybridStrokeTextViewStateUpdater::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "StrokeTextView",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridStrokeTextViewSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::stroketext

package/nitrogen/generated/android/NitroStrokeTextOnLoad.hpp

@@ -6,20 +6,29 @@
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::stroketext {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of NitroStrokeText, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of NitroStrokeText, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::stroketext::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroStrokeText HybridObjects
+   *     margelo::nitro::stroketext::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::stroketext

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

@@ -37,281 +37,275 @@ namespace margelo::nitro::stroketext { enum class StrokeTextEllipsizeMode; }
 
 namespace margelo::nitro::stroketext {
 
-  jni::local_ref<JHybridStrokeTextViewSpec::jhybriddata> JHybridStrokeTextViewSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void JHybridStrokeTextViewSpec::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", JHybridStrokeTextViewSpec::initHybrid),
-    });
+  std::shared_ptr<JHybridStrokeTextViewSpec> JHybridStrokeTextViewSpec::JavaPart::getJHybridStrokeTextViewSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridStrokeTextViewSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridStrokeTextViewSpec!");
+    }
+    return castHybridObject;
   }
 
-  size_t JHybridStrokeTextViewSpec::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<JHybridStrokeTextViewSpec::CxxPart::jhybriddata> JHybridStrokeTextViewSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool JHybridStrokeTextViewSpec::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<JHybridStrokeTextViewSpec>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> JHybridStrokeTextViewSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridStrokeTextViewSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridStrokeTextViewSpec::JavaPart!");
     }
-    return false;
-  }
-
-  void JHybridStrokeTextViewSpec::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
+    return std::make_shared<JHybridStrokeTextViewSpec>(castJavaPart);
   }
 
-  std::string JHybridStrokeTextViewSpec::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void JHybridStrokeTextViewSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridStrokeTextViewSpec::CxxPart::initHybrid),
+    });
   }
 
   // Properties
   std::string JHybridStrokeTextViewSpec::getText() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getText");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getText");
     auto __result = method(_javaPart);
     return __result->toStdString();
   }
   void JHybridStrokeTextViewSpec::setText(const std::string& text) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("setText");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("setText");
     method(_javaPart, jni::make_jstring(text));
   }
   std::optional<std::string> JHybridStrokeTextViewSpec::getColor() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getColor");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getColor");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setColor(const std::optional<std::string>& color) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* color */)>("setColor");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* color */)>("setColor");
     method(_javaPart, color.has_value() ? jni::make_jstring(color.value()) : nullptr);
   }
   std::optional<std::string> JHybridStrokeTextViewSpec::getStrokeColor() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getStrokeColor");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getStrokeColor");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setStrokeColor(const std::optional<std::string>& strokeColor) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* strokeColor */)>("setStrokeColor");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* strokeColor */)>("setStrokeColor");
     method(_javaPart, strokeColor.has_value() ? jni::make_jstring(strokeColor.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getStrokeWidth() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getStrokeWidth");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getStrokeWidth");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setStrokeWidth(std::optional<double> strokeWidth) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* strokeWidth */)>("setStrokeWidth");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* strokeWidth */)>("setStrokeWidth");
     method(_javaPart, strokeWidth.has_value() ? jni::JDouble::valueOf(strokeWidth.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getFontSize() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getFontSize");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getFontSize");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setFontSize(std::optional<double> fontSize) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* fontSize */)>("setFontSize");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* fontSize */)>("setFontSize");
     method(_javaPart, fontSize.has_value() ? jni::JDouble::valueOf(fontSize.value()) : nullptr);
   }
   std::optional<std::string> JHybridStrokeTextViewSpec::getFontWeight() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontWeight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontWeight");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setFontWeight(const std::optional<std::string>& fontWeight) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontWeight */)>("setFontWeight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontWeight */)>("setFontWeight");
     method(_javaPart, fontWeight.has_value() ? jni::make_jstring(fontWeight.value()) : nullptr);
   }
   std::optional<std::string> JHybridStrokeTextViewSpec::getFontFamily() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontFamily");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFontFamily");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setFontFamily(const std::optional<std::string>& fontFamily) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontFamily */)>("setFontFamily");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fontFamily */)>("setFontFamily");
     method(_javaPart, fontFamily.has_value() ? jni::make_jstring(fontFamily.value()) : nullptr);
   }
   std::optional<StrokeTextFontStyle> JHybridStrokeTextViewSpec::getFontStyle() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextFontStyle>()>("getFontStyle");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextFontStyle>()>("getFontStyle");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setFontStyle(std::optional<StrokeTextFontStyle> fontStyle) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextFontStyle> /* fontStyle */)>("setFontStyle");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextFontStyle> /* fontStyle */)>("setFontStyle");
     method(_javaPart, fontStyle.has_value() ? JStrokeTextFontStyle::fromCpp(fontStyle.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getLineHeight() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getLineHeight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getLineHeight");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setLineHeight(std::optional<double> lineHeight) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* lineHeight */)>("setLineHeight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* lineHeight */)>("setLineHeight");
     method(_javaPart, lineHeight.has_value() ? jni::JDouble::valueOf(lineHeight.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getLetterSpacing() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getLetterSpacing");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getLetterSpacing");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setLetterSpacing(std::optional<double> letterSpacing) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* letterSpacing */)>("setLetterSpacing");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* letterSpacing */)>("setLetterSpacing");
     method(_javaPart, letterSpacing.has_value() ? jni::JDouble::valueOf(letterSpacing.value()) : nullptr);
   }
   std::optional<StrokeTextAlign> JHybridStrokeTextViewSpec::getTextAlign() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextAlign>()>("getTextAlign");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextAlign>()>("getTextAlign");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setTextAlign(std::optional<StrokeTextAlign> textAlign) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextAlign> /* textAlign */)>("setTextAlign");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextAlign> /* textAlign */)>("setTextAlign");
     method(_javaPart, textAlign.has_value() ? JStrokeTextAlign::fromCpp(textAlign.value()) : nullptr);
   }
   std::optional<StrokeTextAlignVertical> JHybridStrokeTextViewSpec::getTextAlignVertical() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextAlignVertical>()>("getTextAlignVertical");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextAlignVertical>()>("getTextAlignVertical");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setTextAlignVertical(std::optional<StrokeTextAlignVertical> textAlignVertical) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextAlignVertical> /* textAlignVertical */)>("setTextAlignVertical");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextAlignVertical> /* textAlignVertical */)>("setTextAlignVertical");
     method(_javaPart, textAlignVertical.has_value() ? JStrokeTextAlignVertical::fromCpp(textAlignVertical.value()) : nullptr);
   }
   std::optional<StrokeTextDecorationLine> JHybridStrokeTextViewSpec::getTextDecorationLine() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextDecorationLine>()>("getTextDecorationLine");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextDecorationLine>()>("getTextDecorationLine");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setTextDecorationLine(std::optional<StrokeTextDecorationLine> textDecorationLine) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextDecorationLine> /* textDecorationLine */)>("setTextDecorationLine");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextDecorationLine> /* textDecorationLine */)>("setTextDecorationLine");
     method(_javaPart, textDecorationLine.has_value() ? JStrokeTextDecorationLine::fromCpp(textDecorationLine.value()) : nullptr);
   }
   std::optional<StrokeTextTransform> JHybridStrokeTextViewSpec::getTextTransform() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextTransform>()>("getTextTransform");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextTransform>()>("getTextTransform");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setTextTransform(std::optional<StrokeTextTransform> textTransform) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextTransform> /* textTransform */)>("setTextTransform");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextTransform> /* textTransform */)>("setTextTransform");
     method(_javaPart, textTransform.has_value() ? JStrokeTextTransform::fromCpp(textTransform.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getOpacity() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getOpacity");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getOpacity");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setOpacity(std::optional<double> opacity) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* opacity */)>("setOpacity");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* opacity */)>("setOpacity");
     method(_javaPart, opacity.has_value() ? jni::JDouble::valueOf(opacity.value()) : nullptr);
   }
   std::optional<bool> JHybridStrokeTextViewSpec::getAllowFontScaling() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getAllowFontScaling");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getAllowFontScaling");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setAllowFontScaling(std::optional<bool> allowFontScaling) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* allowFontScaling */)>("setAllowFontScaling");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* allowFontScaling */)>("setAllowFontScaling");
     method(_javaPart, allowFontScaling.has_value() ? jni::JBoolean::valueOf(allowFontScaling.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getMaxFontSizeMultiplier() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxFontSizeMultiplier");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxFontSizeMultiplier");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setMaxFontSizeMultiplier(std::optional<double> maxFontSizeMultiplier) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxFontSizeMultiplier */)>("setMaxFontSizeMultiplier");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxFontSizeMultiplier */)>("setMaxFontSizeMultiplier");
     method(_javaPart, maxFontSizeMultiplier.has_value() ? jni::JDouble::valueOf(maxFontSizeMultiplier.value()) : nullptr);
   }
   std::optional<bool> JHybridStrokeTextViewSpec::getIncludeFontPadding() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getIncludeFontPadding");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getIncludeFontPadding");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setIncludeFontPadding(std::optional<bool> includeFontPadding) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* includeFontPadding */)>("setIncludeFontPadding");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* includeFontPadding */)>("setIncludeFontPadding");
     method(_javaPart, includeFontPadding.has_value() ? jni::JBoolean::valueOf(includeFontPadding.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getNumberOfLines() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getNumberOfLines");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getNumberOfLines");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setNumberOfLines(std::optional<double> numberOfLines) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* numberOfLines */)>("setNumberOfLines");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* numberOfLines */)>("setNumberOfLines");
     method(_javaPart, numberOfLines.has_value() ? jni::JDouble::valueOf(numberOfLines.value()) : nullptr);
   }
   std::optional<StrokeTextEllipsizeMode> JHybridStrokeTextViewSpec::getEllipsizeMode() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JStrokeTextEllipsizeMode>()>("getEllipsizeMode");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JStrokeTextEllipsizeMode>()>("getEllipsizeMode");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setEllipsizeMode(std::optional<StrokeTextEllipsizeMode> ellipsizeMode) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextEllipsizeMode> /* ellipsizeMode */)>("setEllipsizeMode");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JStrokeTextEllipsizeMode> /* ellipsizeMode */)>("setEllipsizeMode");
     method(_javaPart, ellipsizeMode.has_value() ? JStrokeTextEllipsizeMode::fromCpp(ellipsizeMode.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPadding() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPadding");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPadding");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPadding(std::optional<double> padding) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* padding */)>("setPadding");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* padding */)>("setPadding");
     method(_javaPart, padding.has_value() ? jni::JDouble::valueOf(padding.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingVertical() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingVertical");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingVertical");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingVertical(std::optional<double> paddingVertical) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingVertical */)>("setPaddingVertical");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingVertical */)>("setPaddingVertical");
     method(_javaPart, paddingVertical.has_value() ? jni::JDouble::valueOf(paddingVertical.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingHorizontal() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingHorizontal");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingHorizontal");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingHorizontal(std::optional<double> paddingHorizontal) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingHorizontal */)>("setPaddingHorizontal");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingHorizontal */)>("setPaddingHorizontal");
     method(_javaPart, paddingHorizontal.has_value() ? jni::JDouble::valueOf(paddingHorizontal.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingTop() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingTop");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingTop");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingTop(std::optional<double> paddingTop) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingTop */)>("setPaddingTop");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingTop */)>("setPaddingTop");
     method(_javaPart, paddingTop.has_value() ? jni::JDouble::valueOf(paddingTop.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingRight() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingRight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingRight");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingRight(std::optional<double> paddingRight) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingRight */)>("setPaddingRight");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingRight */)>("setPaddingRight");
     method(_javaPart, paddingRight.has_value() ? jni::JDouble::valueOf(paddingRight.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingBottom() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingBottom");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingBottom");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingBottom(std::optional<double> paddingBottom) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingBottom */)>("setPaddingBottom");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingBottom */)>("setPaddingBottom");
     method(_javaPart, paddingBottom.has_value() ? jni::JDouble::valueOf(paddingBottom.value()) : nullptr);
   }
   std::optional<double> JHybridStrokeTextViewSpec::getPaddingLeft() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingLeft");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPaddingLeft");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
   }
   void JHybridStrokeTextViewSpec::setPaddingLeft(std::optional<double> paddingLeft) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingLeft */)>("setPaddingLeft");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* paddingLeft */)>("setPaddingLeft");
     method(_javaPart, paddingLeft.has_value() ? jni::JDouble::valueOf(paddingLeft.value()) : nullptr);
   }