react-native-unistyles 3.0.0-alpha.4 → 3.0.0-alpha.40

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

@@ -55,7 +55,7 @@ namespace margelo::nitro::unistyles {
    * the future, HybridNativePlatformSpecCxx can directly inherit from the C++ class HybridNativePlatformSpec
    * to simplify the whole structure and memory management.
    */
-  class HybridNativePlatformSpecSwift final: public HybridNativePlatformSpec {
+  class HybridNativePlatformSpecSwift: public virtual HybridNativePlatformSpec {
   public:
     // Constructor from a Swift instance
     explicit HybridNativePlatformSpecSwift(const Unistyles::HybridNativePlatformSpecCxx& swiftPart):
@@ -121,18 +121,12 @@ namespace margelo::nitro::unistyles {
     inline void setRootViewBackgroundColor(double color) override {
       _swiftPart.setRootViewBackgroundColor(std::forward<decltype(color)>(color));
     }
-    inline void setNavigationBarBackgroundColor(double color) override {
-      _swiftPart.setNavigationBarBackgroundColor(std::forward<decltype(color)>(color));
-    }
     inline void setNavigationBarHidden(bool isHidden) override {
       _swiftPart.setNavigationBarHidden(std::forward<decltype(isHidden)>(isHidden));
     }
     inline void setStatusBarHidden(bool isHidden) override {
       _swiftPart.setStatusBarHidden(std::forward<decltype(isHidden)>(isHidden));
     }
-    inline void setStatusBarBackgroundColor(double color) override {
-      _swiftPart.setStatusBarBackgroundColor(std::forward<decltype(color)>(color));
-    }
     inline void setImmersiveMode(bool isEnabled) override {
       _swiftPart.setImmersiveMode(std::forward<decltype(isEnabled)>(isEnabled));
     }
@@ -140,9 +134,15 @@ namespace margelo::nitro::unistyles {
       auto __result = _swiftPart.getMiniRuntime();
       return __result;
     }
-    inline void registerPlatformListener(const std::function<void(const std::vector<UnistyleDependency>& /* dependencies */)>& callback) override {
+    inline void registerPlatformListener(const std::function<void(const std::vector<UnistyleDependency>& /* dependencies */, const UnistylesNativeMiniRuntime& /* miniRuntime */)>& callback) override {
       _swiftPart.registerPlatformListener(callback);
     }
+    inline void registerImeListener(const std::function<void(const UnistylesNativeMiniRuntime& /* miniRuntime */)>& callback) override {
+      _swiftPart.registerImeListener(callback);
+    }
+    inline void unregisterPlatformListeners() override {
+      _swiftPart.unregisterPlatformListeners();
+    }
 
   private:
     Unistyles::HybridNativePlatformSpecCxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridNativePlatformSpec.swift

@@ -27,7 +27,7 @@ import NitroModules
  * }
  * ```
  */
-public protocol HybridNativePlatformSpec: HybridObjectSpec {
+public protocol HybridNativePlatformSpec: AnyObject, HybridObjectSpec {
   // Properties
   
 
@@ -43,23 +43,11 @@ public protocol HybridNativePlatformSpec: HybridObjectSpec {
   func getNavigationBarDimensions() throws -> Dimensions
   func getPrefersRtlDirection() throws -> Bool
   func setRootViewBackgroundColor(color: Double) throws -> Void
-  func setNavigationBarBackgroundColor(color: Double) throws -> Void
   func setNavigationBarHidden(isHidden: Bool) throws -> Void
   func setStatusBarHidden(isHidden: Bool) throws -> Void
-  func setStatusBarBackgroundColor(color: Double) throws -> Void
   func setImmersiveMode(isEnabled: Bool) throws -> Void
   func getMiniRuntime() throws -> UnistylesNativeMiniRuntime
-  func registerPlatformListener(callback: @escaping ((_ dependencies: [UnistyleDependency]) -> Void)) throws -> Void
-}
-
-public extension HybridNativePlatformSpec {
-  /**
-   * Create a new instance of HybridNativePlatformSpecCxx for the given HybridNativePlatformSpec.
-   *
-   * Instances of HybridNativePlatformSpecCxx can be accessed from C++, and contain
-   * additional required bridging code for C++ <> Swift interop.
-   */
-  func createCxxBridge() -> HybridNativePlatformSpecCxx {
-    return HybridNativePlatformSpecCxx(self)
-  }
+  func registerPlatformListener(callback: @escaping ((_ dependencies: [UnistyleDependency], _ miniRuntime: UnistylesNativeMiniRuntime) -> Void)) throws -> Void
+  func registerImeListener(callback: @escaping ((_ miniRuntime: UnistylesNativeMiniRuntime) -> Void)) throws -> Void
+  func unregisterPlatformListeners() throws -> Void
 }

package/nitrogen/generated/ios/swift/HybridNativePlatformSpecCxx.swift

@@ -8,6 +8,30 @@
 import Foundation
 import NitroModules
 
+/**
+ * Helper class for converting instances of `HybridNativePlatformSpecCxx` from- and to unsafe pointers.
+ * This is useful to pass Swift classes to C++, without having to strongly type the C++ function signature.
+ * The actual Swift type can be included in the .cpp file, without having to forward-declare anything in .hpp.
+ */
+public final class HybridNativePlatformSpecCxxUnsafe {
+  /**
+   * Casts a `HybridNativePlatformSpecCxx` instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public static func toUnsafe(_ instance: HybridNativePlatformSpecCxx) -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(instance).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNativePlatformSpecCxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNativePlatformSpecCxx>`.
+   * This removes one strong reference from the object!
+   */
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNativePlatformSpecCxx {
+    return Unmanaged<HybridNativePlatformSpecCxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+}
+
 /**
  * A class implementation that bridges HybridNativePlatformSpec over to C++.
  * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
@@ -17,7 +41,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++
  */
-public final class HybridNativePlatformSpecCxx {
+public class HybridNativePlatformSpecCxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::unistyles::bridge::swift`)
    * from `Unistyles-Swift-Cxx-Bridge.hpp`.
@@ -28,25 +52,36 @@ public final class HybridNativePlatformSpecCxx {
   /**
    * Holds an instance of the `HybridNativePlatformSpec` Swift protocol.
    */
-  private(set) var implementation: HybridNativePlatformSpec
+  private var __implementation: any HybridNativePlatformSpec
 
   /**
    * Create a new `HybridNativePlatformSpecCxx` that wraps the given `HybridNativePlatformSpec`.
    * All properties and methods bridge to C++ types.
    */
-  public init(_ implementation: HybridNativePlatformSpec) {
-    self.implementation = implementation
+  public init(_ implementation: some HybridNativePlatformSpec) {
+    self.__implementation = implementation
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridNativePlatformSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNativePlatformSpec() -> any HybridNativePlatformSpec {
+    return __implementation
   }
 
   /**
    * Contains a (weak) reference to the C++ HybridObject to cache it.
    */
   public var hybridContext: margelo.nitro.HybridContext {
+    @inline(__always)
     get {
-      return self.implementation.hybridContext
+      return self.__implementation.hybridContext
     }
+    @inline(__always)
     set {
-      self.implementation.hybridContext = newValue
+      self.__implementation.hybridContext = newValue
     }
   }
 
@@ -54,220 +89,226 @@ public final class HybridNativePlatformSpecCxx {
    * Get the memory size of the Swift class (plus size of any other allocations)
    * so the JS VM can properly track it and garbage-collect the JS object if needed.
    */
+  @inline(__always)
   public var memorySize: Int {
-    return self.implementation.memorySize
+    return self.__implementation.memorySize
   }
 
   // Properties
-
+  
 
   // Methods
   @inline(__always)
   public func getInsets() -> Insets {
     do {
-      let result = try self.implementation.getInsets()
-      return result
+      let __result = try self.__implementation.getInsets()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getColorScheme() -> Int32 {
     do {
-      let result = try self.implementation.getColorScheme()
-      return result.rawValue
+      let __result = try self.__implementation.getColorScheme()
+      return __result.rawValue
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getFontScale() -> Double {
     do {
-      let result = try self.implementation.getFontScale()
-      return result
+      let __result = try self.__implementation.getFontScale()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getPixelRatio() -> Double {
     do {
-      let result = try self.implementation.getPixelRatio()
-      return result
+      let __result = try self.__implementation.getPixelRatio()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getOrientation() -> Int32 {
     do {
-      let result = try self.implementation.getOrientation()
-      return result.rawValue
+      let __result = try self.__implementation.getOrientation()
+      return __result.rawValue
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getContentSizeCategory() -> std.string {
     do {
-      let result = try self.implementation.getContentSizeCategory()
-      return std.string(result)
+      let __result = try self.__implementation.getContentSizeCategory()
+      return std.string(__result)
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getScreenDimensions() -> Dimensions {
     do {
-      let result = try self.implementation.getScreenDimensions()
-      return result
+      let __result = try self.__implementation.getScreenDimensions()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getStatusBarDimensions() -> Dimensions {
     do {
-      let result = try self.implementation.getStatusBarDimensions()
-      return result
+      let __result = try self.__implementation.getStatusBarDimensions()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getNavigationBarDimensions() -> Dimensions {
     do {
-      let result = try self.implementation.getNavigationBarDimensions()
-      return result
+      let __result = try self.__implementation.getNavigationBarDimensions()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func getPrefersRtlDirection() -> Bool {
     do {
-      let result = try self.implementation.getPrefersRtlDirection()
-      return result
+      let __result = try self.__implementation.getPrefersRtlDirection()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
   public func setRootViewBackgroundColor(color: Double) -> Void {
     do {
-      try self.implementation.setRootViewBackgroundColor(color: color)
-      return
+      try self.__implementation.setRootViewBackgroundColor(color: color)
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func setNavigationBarBackgroundColor(color: Double) -> Void {
+  public func setNavigationBarHidden(isHidden: Bool) -> Void {
     do {
-      try self.implementation.setNavigationBarBackgroundColor(color: color)
-      return
+      try self.__implementation.setNavigationBarHidden(isHidden: isHidden)
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func setNavigationBarHidden(isHidden: Bool) -> Void {
+  public func setStatusBarHidden(isHidden: Bool) -> Void {
     do {
-      try self.implementation.setNavigationBarHidden(isHidden: isHidden)
-      return
+      try self.__implementation.setStatusBarHidden(isHidden: isHidden)
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func setStatusBarHidden(isHidden: Bool) -> Void {
+  public func setImmersiveMode(isEnabled: Bool) -> Void {
     do {
-      try self.implementation.setStatusBarHidden(isHidden: isHidden)
-      return
+      try self.__implementation.setImmersiveMode(isEnabled: isEnabled)
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func setStatusBarBackgroundColor(color: Double) -> Void {
+  public func getMiniRuntime() -> UnistylesNativeMiniRuntime {
     do {
-      try self.implementation.setStatusBarBackgroundColor(color: color)
-      return
+      let __result = try self.__implementation.getMiniRuntime()
+      return __result
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func setImmersiveMode(isEnabled: Bool) -> Void {
+  public func registerPlatformListener(callback: bridge.Func_void_std__vector_UnistyleDependency__UnistylesNativeMiniRuntime) -> Void {
     do {
-      try self.implementation.setImmersiveMode(isEnabled: isEnabled)
-      return
+      try self.__implementation.registerPlatformListener(callback: { () -> (([UnistyleDependency], UnistylesNativeMiniRuntime) -> Void) in
+        let __sharedClosure = bridge.share_Func_void_std__vector_UnistyleDependency__UnistylesNativeMiniRuntime(callback)
+        return { (__dependencies: [UnistyleDependency], __miniRuntime: UnistylesNativeMiniRuntime) -> Void in
+          __sharedClosure.pointee.call({ () -> bridge.std__vector_UnistyleDependency_ in
+          var __vector = bridge.create_std__vector_UnistyleDependency_(__dependencies.count)
+          for __item in __dependencies {
+            __vector.push_back(__item)
+          }
+          return __vector
+        }(), __miniRuntime)
+        }
+      }())
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func getMiniRuntime() -> UnistylesNativeMiniRuntime {
+  public func registerImeListener(callback: bridge.Func_void_UnistylesNativeMiniRuntime) -> Void {
     do {
-      let result = try self.implementation.getMiniRuntime()
-      return result
+      try self.__implementation.registerImeListener(callback: { () -> ((UnistylesNativeMiniRuntime) -> Void) in
+        let __sharedClosure = bridge.share_Func_void_UnistylesNativeMiniRuntime(callback)
+        return { (__miniRuntime: UnistylesNativeMiniRuntime) -> Void in
+          __sharedClosure.pointee.call(__miniRuntime)
+        }
+      }())
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
-
+  
   @inline(__always)
-  public func registerPlatformListener(callback: bridge.Func_void_std__vector_UnistyleDependency_) -> Void {
+  public func unregisterPlatformListeners() -> Void {
     do {
-      try self.implementation.registerPlatformListener(callback: { () -> (([UnistyleDependency]) -> Void) in
-        let shared = bridge.share_Func_void_std__vector_UnistyleDependency_(callback)
-        return { (dependencies: [UnistyleDependency]) -> Void in
-          shared.pointee.call({ () -> bridge.std__vector_UnistyleDependency_ in
-          var vector = bridge.create_std__vector_UnistyleDependency_(dependencies.count)
-          for item in dependencies {
-            vector.push_back(item)
-          }
-          return vector
-        }())
-        }
-      }())
-      return
+      try self.__implementation.unregisterPlatformListeners()
+      return 
     } catch {
-      let message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(message))")
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
     }
   }
 }

package/nitrogen/generated/ios/swift/UnistyleDependency.swift

@@ -45,6 +45,8 @@ public extension UnistyleDependency {
         self = .statusbar
       case "NavigationBar":
         self = .navigationbar
+      case "Ime":
+        self = .ime
       default:
         return nil
     }
@@ -83,6 +85,8 @@ public extension UnistyleDependency {
         return "StatusBar"
       case .navigationbar:
         return "NavigationBar"
+      case .ime:
+        return "Ime"
     }
   }
 }

package/nitrogen/generated/ios/swift/UnistylesNativeMiniRuntime.swift

@@ -18,8 +18,8 @@ public extension UnistylesNativeMiniRuntime {
   /**
    * Create a new instance of `UnistylesNativeMiniRuntime`.
    */
-  init(colorScheme: ColorScheme, screen: Dimensions, contentSizeCategory: String, insets: Insets, pixelRatio: Double, fontScale: Double, rtl: Bool, statusBar: Dimensions, navigationBar: Dimensions, orientation: Orientation) {
-    self.init(colorScheme, screen, std.string(contentSizeCategory), insets, pixelRatio, fontScale, rtl, statusBar, navigationBar, orientation)
+  init(colorScheme: ColorScheme, screen: Dimensions, contentSizeCategory: String, insets: Insets, pixelRatio: Double, fontScale: Double, rtl: Bool, statusBar: Dimensions, navigationBar: Dimensions, isPortrait: Bool, isLandscape: Bool) {
+    self.init(colorScheme, screen, std.string(contentSizeCategory), insets, pixelRatio, fontScale, rtl, statusBar, navigationBar, isPortrait, isLandscape)
   }
 
   var colorScheme: ColorScheme {
@@ -121,14 +121,25 @@ public extension UnistylesNativeMiniRuntime {
     }
   }
   
-  var orientation: Orientation {
+  var isPortrait: Bool {
     @inline(__always)
     get {
-      return self.__orientation
+      return self.__isPortrait
     }
     @inline(__always)
     set {
-      self.__orientation = newValue
+      self.__isPortrait = newValue
+    }
+  }
+  
+  var isLandscape: Bool {
+    @inline(__always)
+    get {
+      return self.__isLandscape
+    }
+    @inline(__always)
+    set {
+      self.__isLandscape = newValue
     }
   }
 }

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

@@ -50,7 +50,7 @@ namespace margelo::nitro {
         case hashString("light"): return ColorScheme::LIGHT;
         case hashString("unspecified"): return ColorScheme::UNSPECIFIED;
         default: [[unlikely]]
-          throw std::runtime_error("Cannot convert \"" + unionValue + "\" to enum ColorScheme - invalid value!");
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum ColorScheme - invalid value!");
       }
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, ColorScheme arg) {
@@ -59,7 +59,7 @@ namespace margelo::nitro {
         case ColorScheme::LIGHT: return JSIConverter<std::string>::toJSI(runtime, "light");
         case ColorScheme::UNSPECIFIED: return JSIConverter<std::string>::toJSI(runtime, "unspecified");
         default: [[unlikely]]
-          throw std::runtime_error("Cannot convert ColorScheme to JS - invalid value: "
+          throw std::invalid_argument("Cannot convert ColorScheme to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
       }
     }

package/nitrogen/generated/shared/c++/HybridNativePlatformSpec.cpp

@@ -25,13 +25,13 @@ namespace margelo::nitro::unistyles {
       prototype.registerHybridMethod("getNavigationBarDimensions", &HybridNativePlatformSpec::getNavigationBarDimensions);
       prototype.registerHybridMethod("getPrefersRtlDirection", &HybridNativePlatformSpec::getPrefersRtlDirection);
       prototype.registerHybridMethod("setRootViewBackgroundColor", &HybridNativePlatformSpec::setRootViewBackgroundColor);
-      prototype.registerHybridMethod("setNavigationBarBackgroundColor", &HybridNativePlatformSpec::setNavigationBarBackgroundColor);
       prototype.registerHybridMethod("setNavigationBarHidden", &HybridNativePlatformSpec::setNavigationBarHidden);
       prototype.registerHybridMethod("setStatusBarHidden", &HybridNativePlatformSpec::setStatusBarHidden);
-      prototype.registerHybridMethod("setStatusBarBackgroundColor", &HybridNativePlatformSpec::setStatusBarBackgroundColor);
       prototype.registerHybridMethod("setImmersiveMode", &HybridNativePlatformSpec::setImmersiveMode);
       prototype.registerHybridMethod("getMiniRuntime", &HybridNativePlatformSpec::getMiniRuntime);
       prototype.registerHybridMethod("registerPlatformListener", &HybridNativePlatformSpec::registerPlatformListener);
+      prototype.registerHybridMethod("registerImeListener", &HybridNativePlatformSpec::registerImeListener);
+      prototype.registerHybridMethod("unregisterPlatformListeners", &HybridNativePlatformSpec::unregisterPlatformListeners);
     });
   }
 

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

@@ -43,9 +43,12 @@ namespace margelo::nitro::unistyles {
   /**
    * An abstract base class for `NativePlatform`
    * Inherit this class to create instances of `HybridNativePlatformSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
    * @example
    * ```cpp
    * class HybridNativePlatform: public HybridNativePlatformSpec {
+   * public:
+   *   HybridNativePlatform(...): HybridObject(TAG) { ... }
    *   // ...
    * };
    * ```
@@ -75,13 +78,13 @@ namespace margelo::nitro::unistyles {
       virtual Dimensions getNavigationBarDimensions() = 0;
       virtual bool getPrefersRtlDirection() = 0;
       virtual void setRootViewBackgroundColor(double color) = 0;
-      virtual void setNavigationBarBackgroundColor(double color) = 0;
       virtual void setNavigationBarHidden(bool isHidden) = 0;
       virtual void setStatusBarHidden(bool isHidden) = 0;
-      virtual void setStatusBarBackgroundColor(double color) = 0;
       virtual void setImmersiveMode(bool isEnabled) = 0;
       virtual UnistylesNativeMiniRuntime getMiniRuntime() = 0;
-      virtual void registerPlatformListener(const std::function<void(const std::vector<UnistyleDependency>& /* dependencies */)>& callback) = 0;
+      virtual void registerPlatformListener(const std::function<void(const std::vector<UnistyleDependency>& /* dependencies */, const UnistylesNativeMiniRuntime& /* miniRuntime */)>& callback) = 0;
+      virtual void registerImeListener(const std::function<void(const UnistylesNativeMiniRuntime& /* miniRuntime */)>& callback) = 0;
+      virtual void unregisterPlatformListeners() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridUnistylesNavigationBarSpec.cpp

@@ -16,7 +16,6 @@ namespace margelo::nitro::unistyles {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridGetter("width", &HybridUnistylesNavigationBarSpec::getWidth);
       prototype.registerHybridGetter("height", &HybridUnistylesNavigationBarSpec::getHeight);
-      prototype.registerHybridMethod("setBackgroundColor", &HybridUnistylesNavigationBarSpec::setBackgroundColor);
       prototype.registerHybridMethod("setHidden", &HybridUnistylesNavigationBarSpec::setHidden);
     });
   }

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

@@ -24,9 +24,12 @@ namespace margelo::nitro::unistyles {
   /**
    * An abstract base class for `UnistylesNavigationBar`
    * Inherit this class to create instances of `HybridUnistylesNavigationBarSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
    * @example
    * ```cpp
    * class HybridUnistylesNavigationBar: public HybridUnistylesNavigationBarSpec {
+   * public:
+   *   HybridUnistylesNavigationBar(...): HybridObject(TAG) { ... }
    *   // ...
    * };
    * ```
@@ -46,7 +49,6 @@ namespace margelo::nitro::unistyles {
 
     public:
       // Methods
-      virtual void setBackgroundColor(double color) = 0;
       virtual void setHidden(bool isHidden) = 0;
 
     protected: