@rive-app/react-native 0.2.6 → 0.2.7

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

@@ -0,0 +1,143 @@
+///
+/// JHybridRiveFontConfigSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridRiveFontConfigSpec.hpp"
+
+// Forward declaration of `HybridFallbackFontSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridFallbackFontSpec; }
+
+#include <memory>
+#include "HybridFallbackFontSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JHybridFallbackFontSpec.hpp"
+#include <NitroModules/JUnit.hpp>
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <vector>
+
+namespace margelo::nitro::rive {
+
+  jni::local_ref<JHybridRiveFontConfigSpec::jhybriddata> JHybridRiveFontConfigSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridRiveFontConfigSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRiveFontConfigSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridRiveFontConfigSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridRiveFontConfigSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridRiveFontConfigSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridRiveFontConfigSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridRiveFontConfigSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>> JHybridRiveFontConfigSpec::loadFontFromURL(const std::string& url) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */)>("loadFontFromURL");
+    auto __result = method(_javaPart, jni::make_jstring(url));
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<HybridFallbackFontSpec>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JHybridFallbackFontSpec::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->shared_cast<JHybridFallbackFontSpec>());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<HybridFallbackFontSpec> JHybridRiveFontConfigSpec::loadFontFromResource(const std::string& resource) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridFallbackFontSpec::javaobject>(jni::alias_ref<jni::JString> /* resource */)>("loadFontFromResource");
+    auto __result = method(_javaPart, jni::make_jstring(resource));
+    return __result->cthis()->shared_cast<JHybridFallbackFontSpec>();
+  }
+  std::shared_ptr<HybridFallbackFontSpec> JHybridRiveFontConfigSpec::loadFontFromBytes(const std::shared_ptr<ArrayBuffer>& bytes) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridFallbackFontSpec::javaobject>(jni::alias_ref<JArrayBuffer::javaobject> /* bytes */)>("loadFontFromBytes");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(bytes));
+    return __result->cthis()->shared_cast<JHybridFallbackFontSpec>();
+  }
+  std::shared_ptr<HybridFallbackFontSpec> JHybridRiveFontConfigSpec::loadFontByName(const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridFallbackFontSpec::javaobject>(jni::alias_ref<jni::JString> /* name */)>("loadFontByName");
+    auto __result = method(_javaPart, jni::make_jstring(name));
+    return __result->cthis()->shared_cast<JHybridFallbackFontSpec>();
+  }
+  std::shared_ptr<HybridFallbackFontSpec> JHybridRiveFontConfigSpec::getSystemDefaultFont() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridFallbackFontSpec::javaobject>()>("getSystemDefaultFont");
+    auto __result = method(_javaPart);
+    return __result->cthis()->shared_cast<JHybridFallbackFontSpec>();
+  }
+  void JHybridRiveFontConfigSpec::setFontsForWeight(double weight, const std::vector<std::shared_ptr<HybridFallbackFontSpec>>& fonts) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* weight */, jni::alias_ref<jni::JArrayClass<JHybridFallbackFontSpec::javaobject>> /* fonts */)>("setFontsForWeight");
+    method(_javaPart, weight, [&]() {
+      size_t __size = fonts.size();
+      jni::local_ref<jni::JArrayClass<JHybridFallbackFontSpec::javaobject>> __array = jni::JArrayClass<JHybridFallbackFontSpec::javaobject>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = fonts[__i];
+        auto __elementJni = std::dynamic_pointer_cast<JHybridFallbackFontSpec>(__element)->getJavaPart();
+        __array->setElement(__i, __elementJni.get());
+      }
+      return __array;
+    }());
+  }
+  std::shared_ptr<Promise<void>> JHybridRiveFontConfigSpec::applyFallbackFonts() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("applyFallbackFonts");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridRiveFontConfigSpec::clearFallbackFonts() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearFallbackFonts");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::rive

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

@@ -0,0 +1,73 @@
+///
+/// HybridRiveFontConfigSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRiveFontConfigSpec.hpp"
+
+
+
+
+namespace margelo::nitro::rive {
+
+  using namespace facebook;
+
+  class JHybridRiveFontConfigSpec: public jni::HybridClass<JHybridRiveFontConfigSpec, JHybridObject>,
+                                   public virtual HybridRiveFontConfigSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/rive/HybridRiveFontConfigSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRiveFontConfigSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRiveFontConfigSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRiveFontConfigSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridRiveFontConfigSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>> loadFontFromURL(const std::string& url) override;
+    std::shared_ptr<HybridFallbackFontSpec> loadFontFromResource(const std::string& resource) override;
+    std::shared_ptr<HybridFallbackFontSpec> loadFontFromBytes(const std::shared_ptr<ArrayBuffer>& bytes) override;
+    std::shared_ptr<HybridFallbackFontSpec> loadFontByName(const std::string& name) override;
+    std::shared_ptr<HybridFallbackFontSpec> getSystemDefaultFont() override;
+    void setFontsForWeight(double weight, const std::vector<std::shared_ptr<HybridFallbackFontSpec>>& fonts) override;
+    std::shared_ptr<Promise<void>> applyFallbackFonts() override;
+    std::shared_ptr<Promise<void>> clearFallbackFonts() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRiveFontConfigSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/android/kotlin/com/margelo/nitro/rive/{HybridRiveSpec.kt → HybridFallbackFontSpec.kt}

@@ -1,5 +1,5 @@
 ///
-/// HybridRiveSpec.kt
+/// HybridFallbackFontSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -13,8 +13,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.HybridObject
 
 /**
- * A Kotlin class representing the Rive HybridObject.
- * Implement this abstract class to create Kotlin-based instances of Rive.
+ * A Kotlin class representing the FallbackFont HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of FallbackFont.
  */
 @DoNotStrip
 @Keep
@@ -23,7 +23,7 @@ import com.margelo.nitro.core.HybridObject
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridRiveSpec: HybridObject() {
+abstract class HybridFallbackFontSpec: HybridObject() {
   @DoNotStrip
   private var mHybridData: HybridData = initHybrid()
 
@@ -38,20 +38,18 @@ abstract class HybridRiveSpec: HybridObject() {
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {
-    return "[HybridObject Rive]"
+    return "[HybridObject FallbackFont]"
   }
 
   // Properties
   
 
   // Methods
-  @DoNotStrip
-  @Keep
-  abstract fun multiply(a: Double, b: Double): Double
+  
 
   private external fun initHybrid(): HybridData
 
   companion object {
-    protected const val TAG = "HybridRiveSpec"
+    protected const val TAG = "HybridFallbackFontSpec"
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/rive/HybridRiveFontConfigSpec.kt

@@ -0,0 +1,87 @@
+///
+/// HybridRiveFontConfigSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the RiveFontConfig HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of RiveFontConfig.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridRiveFontConfigSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject RiveFontConfig]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun loadFontFromURL(url: String): Promise<HybridFallbackFontSpec>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun loadFontFromResource(resource: String): HybridFallbackFontSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun loadFontFromBytes(bytes: ArrayBuffer): HybridFallbackFontSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun loadFontByName(name: String): HybridFallbackFontSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getSystemDefaultFont(): HybridFallbackFontSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setFontsForWeight(weight: Double, fonts: Array<HybridFallbackFontSpec>): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun applyFallbackFonts(): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun clearFallbackFonts(): Promise<Unit>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridRiveFontConfigSpec"
+  }
+}

package/nitrogen/generated/android/rive+autolinking.cmake

@@ -34,9 +34,10 @@ target_sources(
   ../nitrogen/generated/android/riveOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridBindableArtboardSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridRiveSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRiveFileSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRiveFileFactorySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridFallbackFontSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridRiveFontConfigSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRiveImageSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRiveImageFactorySpec.cpp
   ../nitrogen/generated/shared/c++/HybridRiveRuntimeSpec.cpp
@@ -56,9 +57,10 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridViewModelArtboardPropertySpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridBindableArtboardSpec.cpp
-  ../nitrogen/generated/android/c++/JHybridRiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRiveFileSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRiveFileFactorySpec.cpp
+  ../nitrogen/generated/android/c++/JHybridFallbackFontSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridRiveFontConfigSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRiveImageSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRiveImageFactorySpec.cpp
   ../nitrogen/generated/android/c++/JHybridRiveRuntimeSpec.cpp

package/nitrogen/generated/android/riveOnLoad.cpp

@@ -16,9 +16,10 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridBindableArtboardSpec.hpp"
-#include "JHybridRiveSpec.hpp"
 #include "JHybridRiveFileSpec.hpp"
 #include "JHybridRiveFileFactorySpec.hpp"
+#include "JHybridFallbackFontSpec.hpp"
+#include "JHybridRiveFontConfigSpec.hpp"
 #include "JHybridRiveImageSpec.hpp"
 #include "JHybridRiveImageFactorySpec.hpp"
 #include "JHybridRiveRuntimeSpec.hpp"
@@ -54,9 +55,10 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
     margelo::nitro::rive::JHybridBindableArtboardSpec::registerNatives();
-    margelo::nitro::rive::JHybridRiveSpec::registerNatives();
     margelo::nitro::rive::JHybridRiveFileSpec::registerNatives();
     margelo::nitro::rive::JHybridRiveFileFactorySpec::registerNatives();
+    margelo::nitro::rive::JHybridFallbackFontSpec::registerNatives();
+    margelo::nitro::rive::JHybridRiveFontConfigSpec::registerNatives();
     margelo::nitro::rive::JHybridRiveImageSpec::registerNatives();
     margelo::nitro::rive::JHybridRiveImageFactorySpec::registerNatives();
     margelo::nitro::rive::JHybridRiveRuntimeSpec::registerNatives();
@@ -83,9 +85,9 @@ int initialize(JavaVM* vm) {
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
-      "Rive",
+      "RiveFontConfig",
       []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridRiveSpec::javaobject> object("com/margelo/nitro/rive/Rive");
+        static DefaultConstructableObject<JHybridRiveFontConfigSpec::javaobject> object("com/margelo/nitro/rive/HybridRiveFontConfig");
         auto instance = object.create();
         return instance->cthis()->shared();
       }

package/nitrogen/generated/ios/RNRive-Swift-Cxx-Bridge.cpp

@@ -9,12 +9,13 @@
 
 // Include C++ implementation defined types
 #include "HybridBindableArtboardSpecSwift.hpp"
+#include "HybridFallbackFontSpecSwift.hpp"
 #include "HybridRiveFileFactorySpecSwift.hpp"
 #include "HybridRiveFileSpecSwift.hpp"
+#include "HybridRiveFontConfigSpecSwift.hpp"
 #include "HybridRiveImageFactorySpecSwift.hpp"
 #include "HybridRiveImageSpecSwift.hpp"
 #include "HybridRiveRuntimeSpecSwift.hpp"
-#include "HybridRiveSpecSwift.hpp"
 #include "HybridRiveViewSpecSwift.hpp"
 #include "HybridViewModelArtboardPropertySpecSwift.hpp"
 #include "HybridViewModelBooleanPropertySpecSwift.hpp"
@@ -49,22 +50,6 @@ namespace margelo::nitro::rive::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
-  // pragma MARK: std::shared_ptr<HybridRiveSpec>
-  std::shared_ptr<HybridRiveSpec> create_std__shared_ptr_HybridRiveSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
-    RNRive::HybridRiveSpec_cxx swiftPart = RNRive::HybridRiveSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::rive::HybridRiveSpecSwift>(swiftPart);
-  }
-  void* NON_NULL get_std__shared_ptr_HybridRiveSpec_(std__shared_ptr_HybridRiveSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::rive::HybridRiveSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::rive::HybridRiveSpecSwift>(cppType);
-    #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridRiveSpec\" is not implemented in Swift!");
-    }
-    #endif
-    RNRive::HybridRiveSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
-  
   // pragma MARK: std::shared_ptr<HybridViewModelSpec>
   std::shared_ptr<HybridViewModelSpec> create_std__shared_ptr_HybridViewModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     RNRive::HybridViewModelSpec_cxx swiftPart = RNRive::HybridViewModelSpec_cxx::fromUnsafe(swiftUnsafePointer);
@@ -145,6 +130,54 @@ namespace margelo::nitro::rive::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::shared_ptr<HybridFallbackFontSpec>
+  std::shared_ptr<HybridFallbackFontSpec> create_std__shared_ptr_HybridFallbackFontSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    RNRive::HybridFallbackFontSpec_cxx swiftPart = RNRive::HybridFallbackFontSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::rive::HybridFallbackFontSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridFallbackFontSpec_(std__shared_ptr_HybridFallbackFontSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::rive::HybridFallbackFontSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::rive::HybridFallbackFontSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridFallbackFontSpec\" is not implemented in Swift!");
+    }
+    #endif
+    RNRive::HybridFallbackFontSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>
+  Func_void_std__shared_ptr_HybridFallbackFontSpec_ create_Func_void_std__shared_ptr_HybridFallbackFontSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = RNRive::Func_void_std__shared_ptr_HybridFallbackFontSpec_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<HybridFallbackFontSpec>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = RNRive::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveFontConfigSpec>
+  std::shared_ptr<HybridRiveFontConfigSpec> create_std__shared_ptr_HybridRiveFontConfigSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    RNRive::HybridRiveFontConfigSpec_cxx swiftPart = RNRive::HybridRiveFontConfigSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::rive::HybridRiveFontConfigSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridRiveFontConfigSpec_(std__shared_ptr_HybridRiveFontConfigSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::rive::HybridRiveFontConfigSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::rive::HybridRiveFontConfigSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridRiveFontConfigSpec\" is not implemented in Swift!");
+    }
+    #endif
+    RNRive::HybridRiveFontConfigSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>
   Func_void_std__shared_ptr_HybridRiveImageSpec_ create_Func_void_std__shared_ptr_HybridRiveImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = RNRive::Func_void_std__shared_ptr_HybridRiveImageSpec_::fromUnsafe(swiftClosureWrapper);
@@ -169,14 +202,6 @@ namespace margelo::nitro::rive::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
-  // pragma MARK: std::function<void()>
-  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = RNRive::Func_void::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
-      swiftClosure.call();
-    };
-  }
-  
   // pragma MARK: std::shared_ptr<HybridRiveRuntimeSpec>
   std::shared_ptr<HybridRiveRuntimeSpec> create_std__shared_ptr_HybridRiveRuntimeSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     RNRive::HybridRiveRuntimeSpec_cxx swiftPart = RNRive::HybridRiveRuntimeSpec_cxx::fromUnsafe(swiftUnsafePointer);