@rive-app/react-native 0.2.6 → 0.2.7

package/nitrogen/generated/ios/c++/HybridRiveFontConfigSpecSwift.hpp

@@ -0,0 +1,145 @@
+///
+/// HybridRiveFontConfigSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveFontConfigSpec.hpp"
+
+// Forward declaration of `HybridRiveFontConfigSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFontConfigSpec_cxx; }
+
+// Forward declaration of `HybridFallbackFontSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridFallbackFontSpec; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <memory>
+#include "HybridFallbackFontSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <vector>
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveFontConfigSpec_cxx.swift.
+   *
+   * HybridRiveFontConfigSpecSwift (C++) accesses HybridRiveFontConfigSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridRiveFontConfigSpec_cxx can directly inherit from the C++ class HybridRiveFontConfigSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveFontConfigSpecSwift: public virtual HybridRiveFontConfigSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveFontConfigSpecSwift(const RNRive::HybridRiveFontConfigSpec_cxx& swiftPart):
+      HybridObject(HybridRiveFontConfigSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveFontConfigSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridRiveFontConfigSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>> loadFontFromURL(const std::string& url) override {
+      auto __result = _swiftPart.loadFontFromURL(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridFallbackFontSpec> loadFontFromResource(const std::string& resource) override {
+      auto __result = _swiftPart.loadFontFromResource(resource);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridFallbackFontSpec> loadFontFromBytes(const std::shared_ptr<ArrayBuffer>& bytes) override {
+      auto __result = _swiftPart.loadFontFromBytes(ArrayBufferHolder(bytes));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridFallbackFontSpec> loadFontByName(const std::string& name) override {
+      auto __result = _swiftPart.loadFontByName(name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridFallbackFontSpec> getSystemDefaultFont() override {
+      auto __result = _swiftPart.getSystemDefaultFont();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setFontsForWeight(double weight, const std::vector<std::shared_ptr<HybridFallbackFontSpec>>& fonts) override {
+      auto __result = _swiftPart.setFontsForWeight(std::forward<decltype(weight)>(weight), fonts);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> applyFallbackFonts() override {
+      auto __result = _swiftPart.applyFallbackFonts();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearFallbackFonts() override {
+      auto __result = _swiftPart.clearFallbackFonts();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RNRive::HybridRiveFontConfigSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_HybridFallbackFontSpec_.swift

@@ -0,0 +1,51 @@
+///
+/// Func_void_std__shared_ptr_HybridFallbackFontSpec_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: (any HybridFallbackFontSpec)) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__shared_ptr_HybridFallbackFontSpec_ {
+  public typealias bridge = margelo.nitro.rive.bridge.swift
+
+  private let closure: (_ value: (any HybridFallbackFontSpec)) -> Void
+
+  public init(_ closure: @escaping (_ value: (any HybridFallbackFontSpec)) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__shared_ptr_HybridFallbackFontSpec_) -> Void {
+    self.closure({ () -> any HybridFallbackFontSpec in
+      let __unsafePointer = bridge.get_std__shared_ptr_HybridFallbackFontSpec_(value)
+      let __instance = HybridFallbackFontSpec_cxx.fromUnsafe(__unsafePointer)
+      return __instance.getHybridFallbackFontSpec()
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_HybridFallbackFontSpec_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_HybridFallbackFontSpec_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_HybridFallbackFontSpec_ {
+    return Unmanaged<Func_void_std__shared_ptr_HybridFallbackFontSpec_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridFallbackFontSpec.swift

@@ -0,0 +1,56 @@
+///
+/// HybridFallbackFontSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridFallbackFontSpec``
+public protocol HybridFallbackFontSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  
+}
+
+public extension HybridFallbackFontSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject FallbackFont]"
+  }
+}
+
+/// See ``HybridFallbackFontSpec``
+open class HybridFallbackFontSpec_base {
+  private weak var cxxWrapper: HybridFallbackFontSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridFallbackFontSpec_cxx {
+  #if DEBUG
+    guard self is any HybridFallbackFontSpec else {
+      fatalError("`self` is not a `HybridFallbackFontSpec`! Did you accidentally inherit from `HybridFallbackFontSpec_base` instead of `HybridFallbackFontSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridFallbackFontSpec_cxx(self as! any HybridFallbackFontSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the FallbackFont HybridObject.
+ * Implement this protocol to create Swift-based instances of FallbackFont.
+ * ```swift
+ * class HybridFallbackFont : HybridFallbackFontSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridFallbackFontSpec = HybridFallbackFontSpec_protocol & HybridFallbackFontSpec_base

package/nitrogen/generated/ios/swift/{HybridRiveSpec_cxx.swift → HybridFallbackFontSpec_cxx.swift}

@@ -1,5 +1,5 @@
 ///
-/// HybridRiveSpec_cxx.swift
+/// HybridFallbackFontSpec_cxx.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -9,7 +9,7 @@ import Foundation
 import NitroModules
 
 /**
- * A class implementation that bridges HybridRiveSpec over to C++.
+ * A class implementation that bridges HybridFallbackFontSpec over to C++.
  * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
  *
  * Also, some Swift types need to be bridged with special handling:
@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-open class HybridRiveSpec_cxx {
+open class HybridFallbackFontSpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::rive::bridge::swift`)
    * from `RNRive-Swift-Cxx-Bridge.hpp`.
@@ -26,30 +26,30 @@ open class HybridRiveSpec_cxx {
   public typealias bridge = margelo.nitro.rive.bridge.swift
 
   /**
-   * Holds an instance of the `HybridRiveSpec` Swift protocol.
+   * Holds an instance of the `HybridFallbackFontSpec` Swift protocol.
    */
-  private var __implementation: any HybridRiveSpec
+  private var __implementation: any HybridFallbackFontSpec
 
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_HybridRiveSpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridFallbackFontSpec_
 
   /**
-   * Create a new `HybridRiveSpec_cxx` that wraps the given `HybridRiveSpec`.
+   * Create a new `HybridFallbackFontSpec_cxx` that wraps the given `HybridFallbackFontSpec`.
    * All properties and methods bridge to C++ types.
    */
-  public init(_ implementation: any HybridRiveSpec) {
+  public init(_ implementation: any HybridFallbackFontSpec) {
     self.__implementation = implementation
     self.__cxxPart = .init()
     /* no base class */
   }
 
   /**
-   * Get the actual `HybridRiveSpec` instance this class wraps.
+   * Get the actual `HybridFallbackFontSpec` instance this class wraps.
    */
   @inline(__always)
-  public func getHybridRiveSpec() -> any HybridRiveSpec {
+  public func getHybridFallbackFontSpec() -> any HybridFallbackFontSpec {
     return __implementation
   }
 
@@ -62,25 +62,25 @@ open class HybridRiveSpec_cxx {
   }
 
   /**
-   * Casts an unsafe pointer to a `HybridRiveSpec_cxx`.
-   * The pointer has to be a retained opaque `Unmanaged<HybridRiveSpec_cxx>`.
+   * Casts an unsafe pointer to a `HybridFallbackFontSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridFallbackFontSpec_cxx>`.
    * This removes one strong reference from the object!
    */
-  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridRiveSpec_cxx {
-    return Unmanaged<HybridRiveSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridFallbackFontSpec_cxx {
+    return Unmanaged<HybridFallbackFontSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
   }
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<HybridRiveSpec>`.
+   * The C++ part is a `std::shared_ptr<HybridFallbackFontSpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_HybridRiveSpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridFallbackFontSpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if Bool(fromCxx: cachedCxxPart) {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_HybridRiveSpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_HybridRiveSpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridFallbackFontSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridFallbackFontSpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -100,7 +100,7 @@ open class HybridRiveSpec_cxx {
    * Compares this object with the given [other] object for reference equality.
    */
   @inline(__always)
-  public func equals(other: HybridRiveSpec_cxx) -> Bool {
+  public func equals(other: HybridFallbackFontSpec_cxx) -> Bool {
     return self.__implementation === other.__implementation
   }
 
@@ -125,15 +125,5 @@ open class HybridRiveSpec_cxx {
   
 
   // Methods
-  @inline(__always)
-  public final func multiply(a: Double, b: Double) -> bridge.Result_double_ {
-    do {
-      let __result = try self.__implementation.multiply(a: a, b: b)
-      let __resultCpp = __result
-      return bridge.create_Result_double_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_double_(__exceptionPtr)
-    }
-  }
+  
 }

package/nitrogen/generated/ios/swift/HybridRiveFontConfigSpec.swift

@@ -0,0 +1,63 @@
+///
+/// HybridRiveFontConfigSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridRiveFontConfigSpec``
+public protocol HybridRiveFontConfigSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func loadFontFromURL(url: String) throws -> Promise<(any HybridFallbackFontSpec)>
+  func loadFontFromResource(resource: String) throws -> (any HybridFallbackFontSpec)
+  func loadFontFromBytes(bytes: ArrayBuffer) throws -> (any HybridFallbackFontSpec)
+  func loadFontByName(name: String) throws -> (any HybridFallbackFontSpec)
+  func getSystemDefaultFont() throws -> (any HybridFallbackFontSpec)
+  func setFontsForWeight(weight: Double, fonts: [(any HybridFallbackFontSpec)]) throws -> Void
+  func applyFallbackFonts() throws -> Promise<Void>
+  func clearFallbackFonts() throws -> Promise<Void>
+}
+
+public extension HybridRiveFontConfigSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject RiveFontConfig]"
+  }
+}
+
+/// See ``HybridRiveFontConfigSpec``
+open class HybridRiveFontConfigSpec_base {
+  private weak var cxxWrapper: HybridRiveFontConfigSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridRiveFontConfigSpec_cxx {
+  #if DEBUG
+    guard self is any HybridRiveFontConfigSpec else {
+      fatalError("`self` is not a `HybridRiveFontConfigSpec`! Did you accidentally inherit from `HybridRiveFontConfigSpec_base` instead of `HybridRiveFontConfigSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridRiveFontConfigSpec_cxx(self as! any HybridRiveFontConfigSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the RiveFontConfig HybridObject.
+ * Implement this protocol to create Swift-based instances of RiveFontConfig.
+ * ```swift
+ * class HybridRiveFontConfig : HybridRiveFontConfigSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridRiveFontConfigSpec = HybridRiveFontConfigSpec_protocol & HybridRiveFontConfigSpec_base