react-native-nitro-list 0.0.1 → 0.1.2

package/nitrogen/generated/android/c++/{JHybridNitroListSpec.hpp → JHybridNitroLayoutEngineSpec.hpp}

@@ -1,5 +1,5 @@
 ///
-/// HybridNitroListSpec.hpp
+/// HybridNitroLayoutEngineSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -9,7 +9,7 @@
 
 #include <NitroModules/JHybridObject.hpp>
 #include <fbjni/fbjni.h>
-#include "HybridNitroListSpec.hpp"
+#include "HybridNitroLayoutEngineSpec.hpp"
 
 
 
@@ -18,22 +18,22 @@ namespace margelo::nitro::nitrolist {
 
   using namespace facebook;
 
-  class JHybridNitroListSpec: public jni::HybridClass<JHybridNitroListSpec, JHybridObject>,
-                              public virtual HybridNitroListSpec {
+  class JHybridNitroLayoutEngineSpec: public jni::HybridClass<JHybridNitroLayoutEngineSpec, JHybridObject>,
+                                      public virtual HybridNitroLayoutEngineSpec {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolist/HybridNitroListSpec;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolist/HybridNitroLayoutEngineSpec;";
     static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridNitroListSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridNitroListSpec::TAG),
+    explicit JHybridNitroLayoutEngineSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroLayoutEngineSpec::TAG),
       HybridBase(jThis),
       _javaPart(jni::make_global(jThis)) {}
 
   public:
-    ~JHybridNitroListSpec() override {
+    ~JHybridNitroLayoutEngineSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
@@ -44,23 +44,22 @@ namespace margelo::nitro::nitrolist {
     std::string toString() override;
 
   public:
-    inline const jni::global_ref<JHybridNitroListSpec::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<JHybridNitroLayoutEngineSpec::javaobject>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
   public:
     // Properties
-    bool getIsRed() override;
-    void setIsRed(bool isRed) override;
+    
 
   public:
     // Methods
-    
+    std::vector<LayoutRect> computeLayout(double containerWidth, const std::vector<double>& itemHeights) override;
 
   private:
     friend HybridBase;
     using HybridBase::HybridBase;
-    jni::global_ref<JHybridNitroListSpec::javaobject> _javaPart;
+    jni::global_ref<JHybridNitroLayoutEngineSpec::javaobject> _javaPart;
   };
 
 } // namespace margelo::nitro::nitrolist

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

@@ -0,0 +1,69 @@
+///
+/// JLayoutRect.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LayoutRect.hpp"
+
+
+
+namespace margelo::nitro::nitrolist {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LayoutRect" and the the Kotlin data class "LayoutRect".
+   */
+  struct JLayoutRect final: public jni::JavaClass<JLayoutRect> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolist/LayoutRect;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LayoutRect by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LayoutRect toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldX = clazz->getField<double>("x");
+      double x = this->getFieldValue(fieldX);
+      static const auto fieldY = clazz->getField<double>("y");
+      double y = this->getFieldValue(fieldY);
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      return LayoutRect(
+        x,
+        y,
+        width,
+        height
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLayoutRect::javaobject> fromCpp(const LayoutRect& value) {
+      using JSignature = JLayoutRect(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.x,
+        value.y,
+        value.width,
+        value.height
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolist

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolist/{HybridNitroListSpec.kt → HybridNitroLayoutEngineSpec.kt}

@@ -1,5 +1,5 @@
 ///
-/// HybridNitroListSpec.kt
+/// HybridNitroLayoutEngineSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -10,11 +10,11 @@ package com.margelo.nitro.nitrolist
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.views.HybridView
+import com.margelo.nitro.core.HybridObject
 
 /**
- * A Kotlin class representing the NitroList HybridObject.
- * Implement this abstract class to create Kotlin-based instances of NitroList.
+ * A Kotlin class representing the NitroLayoutEngine HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NitroLayoutEngine.
  */
 @DoNotStrip
 @Keep
@@ -23,7 +23,7 @@ import com.margelo.nitro.views.HybridView
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridNitroListSpec: HybridView() {
+abstract class HybridNitroLayoutEngineSpec: HybridObject() {
   @DoNotStrip
   private var mHybridData: HybridData = initHybrid()
 
@@ -38,22 +38,20 @@ abstract class HybridNitroListSpec: HybridView() {
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {
-    return "[HybridObject NitroList]"
+    return "[HybridObject NitroLayoutEngine]"
   }
 
   // Properties
-  @get:DoNotStrip
-  @get:Keep
-  @set:DoNotStrip
-  @set:Keep
-  abstract var isRed: Boolean
+  
 
   // Methods
-  
+  @DoNotStrip
+  @Keep
+  abstract fun computeLayout(containerWidth: Double, itemHeights: DoubleArray): Array<LayoutRect>
 
   private external fun initHybrid(): HybridData
 
   companion object {
-    protected const val TAG = "HybridNitroListSpec"
+    protected const val TAG = "HybridNitroLayoutEngineSpec"
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolist/LayoutRect.kt

@@ -0,0 +1,47 @@
+///
+/// LayoutRect.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrolist
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "LayoutRect".
+ */
+@DoNotStrip
+@Keep
+data class LayoutRect(
+  @DoNotStrip
+  @Keep
+  val x: Double,
+  @DoNotStrip
+  @Keep
+  val y: Double,
+  @DoNotStrip
+  @Keep
+  val width: Double,
+  @DoNotStrip
+  @Keep
+  val height: Double
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(x: Double, y: Double, width: Double, height: Double): LayoutRect {
+      return LayoutRect(x, y, width, height)
+    }
+  }
+}

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

@@ -8,25 +8,25 @@
 #include "NitroList-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
-#include "HybridNitroListSpecSwift.hpp"
+#include "HybridNitroLayoutEngineSpecSwift.hpp"
 #include "NitroList-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::nitrolist::bridge::swift {
 
-  // pragma MARK: std::shared_ptr<HybridNitroListSpec>
-  std::shared_ptr<HybridNitroListSpec> create_std__shared_ptr_HybridNitroListSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
-    NitroList::HybridNitroListSpec_cxx swiftPart = NitroList::HybridNitroListSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::nitrolist::HybridNitroListSpecSwift>(swiftPart);
+  // pragma MARK: std::shared_ptr<HybridNitroLayoutEngineSpec>
+  std::shared_ptr<HybridNitroLayoutEngineSpec> create_std__shared_ptr_HybridNitroLayoutEngineSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    NitroList::HybridNitroLayoutEngineSpec_cxx swiftPart = NitroList::HybridNitroLayoutEngineSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::nitrolist::HybridNitroLayoutEngineSpecSwift>(swiftPart);
   }
-  void* NON_NULL get_std__shared_ptr_HybridNitroListSpec_(std__shared_ptr_HybridNitroListSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::nitrolist::HybridNitroListSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::nitrolist::HybridNitroListSpecSwift>(cppType);
+  void* NON_NULL get_std__shared_ptr_HybridNitroLayoutEngineSpec_(std__shared_ptr_HybridNitroLayoutEngineSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::nitrolist::HybridNitroLayoutEngineSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::nitrolist::HybridNitroLayoutEngineSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridNitroListSpec\" is not implemented in Swift!");
+      throw std::runtime_error("Class \"HybridNitroLayoutEngineSpec\" is not implemented in Swift!");
     }
     #endif
-    NitroList::HybridNitroListSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    NitroList::HybridNitroLayoutEngineSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
 

package/nitrogen/generated/ios/NitroList-Swift-Cxx-Bridge.hpp

@@ -8,16 +8,22 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `HybridNitroListSpec` to properly resolve imports.
-namespace margelo::nitro::nitrolist { class HybridNitroListSpec; }
+// Forward declaration of `HybridNitroLayoutEngineSpec` to properly resolve imports.
+namespace margelo::nitro::nitrolist { class HybridNitroLayoutEngineSpec; }
+// Forward declaration of `LayoutRect` to properly resolve imports.
+namespace margelo::nitro::nitrolist { struct LayoutRect; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridNitroListSpec_cxx` to properly resolve imports.
-namespace NitroList { class HybridNitroListSpec_cxx; }
+// Forward declaration of `HybridNitroLayoutEngineSpec_cxx` to properly resolve imports.
+namespace NitroList { class HybridNitroLayoutEngineSpec_cxx; }
 
 // Include C++ defined types
-#include "HybridNitroListSpec.hpp"
+#include "HybridNitroLayoutEngineSpec.hpp"
+#include "LayoutRect.hpp"
+#include <NitroModules/Result.hpp>
+#include <exception>
 #include <memory>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -25,16 +31,47 @@ namespace NitroList { class HybridNitroListSpec_cxx; }
  */
 namespace margelo::nitro::nitrolist::bridge::swift {
 
-  // pragma MARK: std::shared_ptr<HybridNitroListSpec>
+  // pragma MARK: std::vector<LayoutRect>
   /**
-   * Specialized version of `std::shared_ptr<HybridNitroListSpec>`.
+   * Specialized version of `std::vector<LayoutRect>`.
    */
-  using std__shared_ptr_HybridNitroListSpec_ = std::shared_ptr<HybridNitroListSpec>;
-  std::shared_ptr<HybridNitroListSpec> create_std__shared_ptr_HybridNitroListSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridNitroListSpec_(std__shared_ptr_HybridNitroListSpec_ cppType);
+  using std__vector_LayoutRect_ = std::vector<LayoutRect>;
+  inline std::vector<LayoutRect> create_std__vector_LayoutRect_(size_t size) noexcept {
+    std::vector<LayoutRect> vector;
+    vector.reserve(size);
+    return vector;
+  }
   
-  // pragma MARK: std::weak_ptr<HybridNitroListSpec>
-  using std__weak_ptr_HybridNitroListSpec_ = std::weak_ptr<HybridNitroListSpec>;
-  inline std__weak_ptr_HybridNitroListSpec_ weakify_std__shared_ptr_HybridNitroListSpec_(const std::shared_ptr<HybridNitroListSpec>& strong) noexcept { return strong; }
+  // pragma MARK: std::vector<double>
+  /**
+   * Specialized version of `std::vector<double>`.
+   */
+  using std__vector_double_ = std::vector<double>;
+  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
+    std::vector<double> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroLayoutEngineSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroLayoutEngineSpec>`.
+   */
+  using std__shared_ptr_HybridNitroLayoutEngineSpec_ = std::shared_ptr<HybridNitroLayoutEngineSpec>;
+  std::shared_ptr<HybridNitroLayoutEngineSpec> create_std__shared_ptr_HybridNitroLayoutEngineSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroLayoutEngineSpec_(std__shared_ptr_HybridNitroLayoutEngineSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroLayoutEngineSpec>
+  using std__weak_ptr_HybridNitroLayoutEngineSpec_ = std::weak_ptr<HybridNitroLayoutEngineSpec>;
+  inline std__weak_ptr_HybridNitroLayoutEngineSpec_ weakify_std__shared_ptr_HybridNitroLayoutEngineSpec_(const std::shared_ptr<HybridNitroLayoutEngineSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<LayoutRect>>
+  using Result_std__vector_LayoutRect__ = Result<std::vector<LayoutRect>>;
+  inline Result_std__vector_LayoutRect__ create_Result_std__vector_LayoutRect__(const std::vector<LayoutRect>& value) noexcept {
+    return Result<std::vector<LayoutRect>>::withValue(value);
+  }
+  inline Result_std__vector_LayoutRect__ create_Result_std__vector_LayoutRect__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<LayoutRect>>::withError(error);
+  }
 
 } // namespace margelo::nitro::nitrolist::bridge::swift

package/nitrogen/generated/ios/NitroList-Swift-Cxx-Umbrella.hpp

@@ -8,12 +8,18 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `HybridNitroListSpec` to properly resolve imports.
-namespace margelo::nitro::nitrolist { class HybridNitroListSpec; }
+// Forward declaration of `HybridNitroLayoutEngineSpec` to properly resolve imports.
+namespace margelo::nitro::nitrolist { class HybridNitroLayoutEngineSpec; }
+// Forward declaration of `LayoutRect` to properly resolve imports.
+namespace margelo::nitro::nitrolist { struct LayoutRect; }
 
 // Include C++ defined types
-#include "HybridNitroListSpec.hpp"
+#include "HybridNitroLayoutEngineSpec.hpp"
+#include "LayoutRect.hpp"
+#include <NitroModules/Result.hpp>
+#include <exception>
 #include <memory>
+#include <vector>
 
 // C++ helpers for Swift
 #include "NitroList-Swift-Cxx-Bridge.hpp"
@@ -25,8 +31,8 @@ namespace margelo::nitro::nitrolist { class HybridNitroListSpec; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridNitroListSpec_cxx` to properly resolve imports.
-namespace NitroList { class HybridNitroListSpec_cxx; }
+// Forward declaration of `HybridNitroLayoutEngineSpec_cxx` to properly resolve imports.
+namespace NitroList { class HybridNitroLayoutEngineSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("NitroList-Swift.h")

package/nitrogen/generated/ios/c++/{HybridNitroListSpecSwift.cpp → HybridNitroLayoutEngineSpecSwift.cpp}

@@ -1,11 +1,11 @@
 ///
-/// HybridNitroListSpecSwift.cpp
+/// HybridNitroLayoutEngineSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
-#include "HybridNitroListSpecSwift.hpp"
+#include "HybridNitroLayoutEngineSpecSwift.hpp"
 
 namespace margelo::nitro::nitrolist {
 } // namespace margelo::nitro::nitrolist

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

@@ -0,0 +1,78 @@
+///
+/// HybridNitroLayoutEngineSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroLayoutEngineSpec.hpp"
+
+// Forward declaration of `HybridNitroLayoutEngineSpec_cxx` to properly resolve imports.
+namespace NitroList { class HybridNitroLayoutEngineSpec_cxx; }
+
+// Forward declaration of `LayoutRect` to properly resolve imports.
+namespace margelo::nitro::nitrolist { struct LayoutRect; }
+
+#include "LayoutRect.hpp"
+#include <vector>
+
+#include "NitroList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrolist {
+
+  /**
+   * The C++ part of HybridNitroLayoutEngineSpec_cxx.swift.
+   *
+   * HybridNitroLayoutEngineSpecSwift (C++) accesses HybridNitroLayoutEngineSpec_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, HybridNitroLayoutEngineSpec_cxx can directly inherit from the C++ class HybridNitroLayoutEngineSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroLayoutEngineSpecSwift: public virtual HybridNitroLayoutEngineSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroLayoutEngineSpecSwift(const NitroList::HybridNitroLayoutEngineSpec_cxx& swiftPart):
+      HybridObject(HybridNitroLayoutEngineSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroList::HybridNitroLayoutEngineSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::vector<LayoutRect> computeLayout(double containerWidth, const std::vector<double>& itemHeights) override {
+      auto __result = _swiftPart.computeLayout(std::forward<decltype(containerWidth)>(containerWidth), itemHeights);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroList::HybridNitroLayoutEngineSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrolist

package/nitrogen/generated/ios/swift/HybridNitroLayoutEngineSpec.swift

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