aix 0.6.0 → 0.6.1

package/nitrogen/generated/ios/c++/views/HybridAixInputWrapperComponent.mm

@@ -0,0 +1,116 @@
+///
+/// HybridAixInputWrapperComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#import "HybridAixInputWrapperComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridAixInputWrapperSpecSwift.hpp"
+#import "Aix-Swift-Cxx-Umbrella.hpp"
+
+using namespace facebook;
+using namespace margelo::nitro::aix;
+using namespace margelo::nitro::aix::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "AixInputWrapper" HybridView.
+ */
+@interface HybridAixInputWrapperComponent: RCTViewComponentView
+@end
+
+@implementation HybridAixInputWrapperComponent {
+  std::shared_ptr<HybridAixInputWrapperSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridAixInputWrapperComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridAixInputWrapperComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridAixInputWrapperSpec> hybridView = Aix::AixAutolinking::createAixInputWrapper();
+    _hybridView = std::dynamic_pointer_cast<HybridAixInputWrapperSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  Aix::HybridAixInputWrapperSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridAixInputWrapperProps const>(props);
+  auto& newViewProps = const_cast<HybridAixInputWrapperProps&>(newViewPropsConst);
+  Aix::HybridAixInputWrapperSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // pasteConfiguration: optional
+  if (newViewProps.pasteConfiguration.isDirty) {
+    swiftPart.setPasteConfiguration(newViewProps.pasteConfiguration.value);
+    newViewProps.pasteConfiguration.isDirty = false;
+  }
+  // editMenuDefaultActions: optional
+  if (newViewProps.editMenuDefaultActions.isDirty) {
+    swiftPart.setEditMenuDefaultActions(newViewProps.editMenuDefaultActions.value);
+    newViewProps.editMenuDefaultActions.isDirty = false;
+  }
+  // maxLines: optional
+  if (newViewProps.maxLines.isDirty) {
+    swiftPart.setMaxLines(newViewProps.maxLines.value);
+    newViewProps.maxLines.isDirty = false;
+  }
+  // maxChars: optional
+  if (newViewProps.maxChars.isDirty) {
+    swiftPart.setMaxChars(newViewProps.maxChars.value);
+    newViewProps.maxChars.isDirty = false;
+  }
+  // onPaste: optional
+  if (newViewProps.onPaste.isDirty) {
+    swiftPart.setOnPaste(newViewProps.onPaste.value);
+    newViewProps.onPaste.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end

package/nitrogen/generated/ios/swift/AixInputWrapperOnPasteEvent.swift

@@ -0,0 +1,107 @@
+///
+/// AixInputWrapperOnPasteEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `AixInputWrapperOnPasteEvent`, backed by a C++ struct.
+ */
+public typealias AixInputWrapperOnPasteEvent = margelo.nitro.aix.AixInputWrapperOnPasteEvent
+
+public extension AixInputWrapperOnPasteEvent {
+  private typealias bridge = margelo.nitro.aix.bridge.swift
+
+  /**
+   * Create a new instance of `AixInputWrapperOnPasteEvent`.
+   */
+  init(type: String, filePath: String, fileExtension: String?, fileName: String?) {
+    self.init(std.string(type), std.string(filePath), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = fileExtension {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = fileName {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var type: String {
+    @inline(__always)
+    get {
+      return String(self.__type)
+    }
+    @inline(__always)
+    set {
+      self.__type = std.string(newValue)
+    }
+  }
+  
+  var filePath: String {
+    @inline(__always)
+    get {
+      return String(self.__filePath)
+    }
+    @inline(__always)
+    set {
+      self.__filePath = std.string(newValue)
+    }
+  }
+  
+  var fileExtension: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__fileExtension) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__fileExtension)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__fileExtension = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var fileName: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__fileName) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__fileName)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__fileName = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__vector_AixInputWrapperOnPasteEvent_.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__vector_AixInputWrapperOnPasteEvent_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ events: [AixInputWrapperOnPasteEvent]) -> 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__vector_AixInputWrapperOnPasteEvent_ {
+  public typealias bridge = margelo.nitro.aix.bridge.swift
+
+  private let closure: (_ events: [AixInputWrapperOnPasteEvent]) -> Void
+
+  public init(_ closure: @escaping (_ events: [AixInputWrapperOnPasteEvent]) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(events: bridge.std__vector_AixInputWrapperOnPasteEvent_) -> Void {
+    self.closure(events.map({ __item in __item }))
+  }
+
+  /**
+   * 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__vector_AixInputWrapperOnPasteEvent_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__vector_AixInputWrapperOnPasteEvent_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__vector_AixInputWrapperOnPasteEvent_ {
+    return Unmanaged<Func_void_std__vector_AixInputWrapperOnPasteEvent_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridAixComposerSpec.swift

@@ -12,6 +12,7 @@ import NitroModules
 public protocol HybridAixComposerSpec_protocol: HybridObject, HybridView {
   // Properties
   var stickToKeyboard: AixStickToKeyboard? { get set }
+  var fixInput: Bool? { get set }
 
   // Methods
   

package/nitrogen/generated/ios/swift/HybridAixComposerSpec_cxx.swift

@@ -130,6 +130,30 @@ open class HybridAixComposerSpec_cxx {
       self.__implementation.stickToKeyboard = newValue.value
     }
   }
+  
+  public final var fixInput: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.fixInput {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.fixInput = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   public final func getView() -> UnsafeMutableRawPointer {

package/nitrogen/generated/ios/swift/HybridAixDropzoneSpec.swift

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

package/nitrogen/generated/ios/swift/HybridAixDropzoneSpec_cxx.swift

@@ -0,0 +1,167 @@
+///
+/// HybridAixDropzoneSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridAixDropzoneSpec 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:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - 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 HybridAixDropzoneSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::aix::bridge::swift`)
+   * from `Aix-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.aix.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridAixDropzoneSpec` Swift protocol.
+   */
+  private var __implementation: any HybridAixDropzoneSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridAixDropzoneSpec_
+
+  /**
+   * Create a new `HybridAixDropzoneSpec_cxx` that wraps the given `HybridAixDropzoneSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridAixDropzoneSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridAixDropzoneSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridAixDropzoneSpec() -> any HybridAixDropzoneSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridAixDropzoneSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridAixDropzoneSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridAixDropzoneSpec_cxx {
+    return Unmanaged<HybridAixDropzoneSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridAixDropzoneSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridAixDropzoneSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridAixDropzoneSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridAixDropzoneSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * 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 MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var onDrop: bridge.std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______ in
+        if let __unwrappedValue = self.__implementation.onDrop {
+          return bridge.create_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______({ () -> bridge.Func_void_std__vector_AixInputWrapperOnPasteEvent_ in
+            let __closureWrapper = Func_void_std__vector_AixInputWrapperOnPasteEvent_(__unwrappedValue)
+            return bridge.create_Func_void_std__vector_AixInputWrapperOnPasteEvent_(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onDrop = { () -> ((_ events: [AixInputWrapperOnPasteEvent]) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______(newValue)
+          return { () -> ([AixInputWrapperOnPasteEvent]) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__vector_AixInputWrapperOnPasteEvent_(__unwrapped)
+            return { (__events: [AixInputWrapperOnPasteEvent]) -> Void in
+              __wrappedFunction.call({ () -> bridge.std__vector_AixInputWrapperOnPasteEvent_ in
+                var __vector = bridge.create_std__vector_AixInputWrapperOnPasteEvent_(__events.count)
+                for __item in __events {
+                  __vector.push_back(__item)
+                }
+                return __vector
+              }())
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+}

package/nitrogen/generated/ios/swift/HybridAixInputWrapperSpec.swift

@@ -0,0 +1,60 @@
+///
+/// HybridAixInputWrapperSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridAixInputWrapperSpec``
+public protocol HybridAixInputWrapperSpec_protocol: HybridObject, HybridView {
+  // Properties
+  var pasteConfiguration: [String]? { get set }
+  var editMenuDefaultActions: [String]? { get set }
+  var maxLines: Double? { get set }
+  var maxChars: Double? { get set }
+  var onPaste: ((_ events: [AixInputWrapperOnPasteEvent]) -> Void)? { get set }
+
+  // Methods
+  
+}
+
+public extension HybridAixInputWrapperSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject AixInputWrapper]"
+  }
+}
+
+/// See ``HybridAixInputWrapperSpec``
+open class HybridAixInputWrapperSpec_base {
+  private weak var cxxWrapper: HybridAixInputWrapperSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridAixInputWrapperSpec_cxx {
+  #if DEBUG
+    guard self is HybridAixInputWrapperSpec else {
+      fatalError("`self` is not a `HybridAixInputWrapperSpec`! Did you accidentally inherit from `HybridAixInputWrapperSpec_base` instead of `HybridAixInputWrapperSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridAixInputWrapperSpec_cxx(self as! HybridAixInputWrapperSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the AixInputWrapper HybridObject.
+ * Implement this protocol to create Swift-based instances of AixInputWrapper.
+ * ```swift
+ * class HybridAixInputWrapper : HybridAixInputWrapperSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridAixInputWrapperSpec = HybridAixInputWrapperSpec_protocol & HybridAixInputWrapperSpec_base