react-native-nitro-modal 0.2.0 → 0.3.1-rc

package/nitrogen/generated/ios/swift/HybridNitroModalSpec_cxx.swift

@@ -143,20 +143,50 @@ open class HybridNitroModalSpec_cxx {
     }
   }
   
-  public final var detents: bridge.std__vector_SheetDetent_ {
+  public final var isInline: Bool {
     @inline(__always)
     get {
-      return { () -> bridge.std__vector_SheetDetent_ in
-        var __vector = bridge.create_std__vector_SheetDetent_(self.__implementation.detents.count)
+      return self.__implementation.isInline
+    }
+    @inline(__always)
+    set {
+      self.__implementation.isInline = newValue
+    }
+  }
+  
+  public final var detents: bridge.std__vector_std__variant_NamedSheetDetent__double__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__vector_std__variant_NamedSheetDetent__double__ in
+        var __vector = bridge.create_std__vector_std__variant_NamedSheetDetent__double__(self.__implementation.detents.count)
         for __item in self.__implementation.detents {
-          __vector.push_back(__item)
+          __vector.push_back({ () -> bridge.std__variant_NamedSheetDetent__double_ in
+            switch __item {
+              case .first(let __value):
+                return bridge.create_std__variant_NamedSheetDetent__double_(__value)
+              case .second(let __value):
+                return bridge.create_std__variant_NamedSheetDetent__double_(__value)
+            }
+          }().variant)
         }
         return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.detents = newValue.map({ __item in __item })
+      self.__implementation.detents = newValue.map({ __item in { () -> SheetDetent in
+        let __variant = bridge.std__variant_NamedSheetDetent__double_(__item)
+        switch __variant.index() {
+          case 0:
+            let __actual = __variant.get_0()
+            return .first(__actual)
+          case 1:
+            let __actual = __variant.get_1()
+            return .second(__actual)
+          default:
+            fatalError("Variant can never have index \(__variant.index())!")
+        }
+      }() })
     }
   }
   
@@ -305,6 +335,65 @@ open class HybridNitroModalSpec_cxx {
     }
   }
   
+  public final var pullToRefreshEnabled: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.pullToRefreshEnabled
+    }
+    @inline(__always)
+    set {
+      self.__implementation.pullToRefreshEnabled = newValue
+    }
+  }
+  
+  public final var refreshing: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.refreshing {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.refreshing = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var refreshIndicatorColor: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.refreshIndicatorColor {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.refreshIndicatorColor = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var onPresent: bridge.std__optional_std__function_void____ {
     @inline(__always)
     get {
@@ -496,6 +585,70 @@ open class HybridNitroModalSpec_cxx {
       }()
     }
   }
+  
+  public final var onPullToRefresh: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.onPullToRefresh {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPullToRefresh = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onRestingTopChange: bridge.std__optional_std__function_void_double____top______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_double____top______ in
+        if let __unwrappedValue = self.__implementation.onRestingTopChange {
+          return bridge.create_std__optional_std__function_void_double____top______({ () -> bridge.Func_void_double in
+            let __closureWrapper = Func_void_double(__unwrappedValue)
+            return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRestingTopChange = { () -> ((_ top: Double) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_double____top______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_double____top______(newValue)
+          return { () -> (Double) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_double(__unwrapped)
+            return { (__top: Double) -> Void in
+              __wrappedFunction.call(__top)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)

package/nitrogen/generated/ios/swift/NamedSheetDetent.swift

@@ -0,0 +1,48 @@
+///
+/// NamedSheetDetent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `NamedSheetDetent`, backed by a C++ enum.
+ */
+public typealias NamedSheetDetent = margelo.nitro.nitromodal.NamedSheetDetent
+
+public extension NamedSheetDetent {
+  /**
+   * Get a NamedSheetDetent for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "small":
+        self = .small
+      case "medium":
+        self = .medium
+      case "large":
+        self = .large
+      case "fitContent":
+        self = .fitcontent
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this NamedSheetDetent represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .small:
+        return "small"
+      case .medium:
+        return "medium"
+      case .large:
+        return "large"
+      case .fitcontent:
+        return "fitContent"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/SheetDetent.swift

@@ -5,44 +5,26 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
+
+
 /**
- * Represents the JS union `SheetDetent`, backed by a C++ enum.
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `enum | number`
  */
-public typealias SheetDetent = margelo.nitro.nitromodal.SheetDetent
+@frozen
+public indirect enum SheetDetent {
+  case first(NamedSheetDetent)
+  case second(Double)
+}
 
 public extension SheetDetent {
-  /**
-   * Get a SheetDetent for the given String value, or
-   * return `nil` if the given value was invalid/unknown.
-   */
-  init?(fromString string: String) {
-    switch string {
-      case "small":
-        self = .small
-      case "medium":
-        self = .medium
-      case "large":
-        self = .large
-      case "fitContent":
-        self = .fitcontent
-      default:
-        return nil
-    }
-  }
-
-  /**
-   * Get the String value this SheetDetent represents.
-   */
-  var stringValue: String {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
-      case .small:
-        return "small"
-      case .medium:
-        return "medium"
-      case .large:
-        return "large"
-      case .fitcontent:
-        return "fitContent"
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
     }
   }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
 }

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

@@ -18,6 +18,8 @@ namespace margelo::nitro::nitromodal {
       prototype.registerHybridSetter("isOpen", &HybridNitroModalSpec::setIsOpen);
       prototype.registerHybridGetter("mode", &HybridNitroModalSpec::getMode);
       prototype.registerHybridSetter("mode", &HybridNitroModalSpec::setMode);
+      prototype.registerHybridGetter("isInline", &HybridNitroModalSpec::getIsInline);
+      prototype.registerHybridSetter("isInline", &HybridNitroModalSpec::setIsInline);
       prototype.registerHybridGetter("detents", &HybridNitroModalSpec::getDetents);
       prototype.registerHybridSetter("detents", &HybridNitroModalSpec::setDetents);
       prototype.registerHybridGetter("initialDetentIndex", &HybridNitroModalSpec::getInitialDetentIndex);
@@ -44,6 +46,12 @@ namespace margelo::nitro::nitromodal {
       prototype.registerHybridSetter("keyboardBehavior", &HybridNitroModalSpec::setKeyboardBehavior);
       prototype.registerHybridGetter("popupAnimation", &HybridNitroModalSpec::getPopupAnimation);
       prototype.registerHybridSetter("popupAnimation", &HybridNitroModalSpec::setPopupAnimation);
+      prototype.registerHybridGetter("pullToRefreshEnabled", &HybridNitroModalSpec::getPullToRefreshEnabled);
+      prototype.registerHybridSetter("pullToRefreshEnabled", &HybridNitroModalSpec::setPullToRefreshEnabled);
+      prototype.registerHybridGetter("refreshing", &HybridNitroModalSpec::getRefreshing);
+      prototype.registerHybridSetter("refreshing", &HybridNitroModalSpec::setRefreshing);
+      prototype.registerHybridGetter("refreshIndicatorColor", &HybridNitroModalSpec::getRefreshIndicatorColor);
+      prototype.registerHybridSetter("refreshIndicatorColor", &HybridNitroModalSpec::setRefreshIndicatorColor);
       prototype.registerHybridGetter("onPresent", &HybridNitroModalSpec::getOnPresent);
       prototype.registerHybridSetter("onPresent", &HybridNitroModalSpec::setOnPresent);
       prototype.registerHybridGetter("onDismiss", &HybridNitroModalSpec::getOnDismiss);
@@ -56,6 +64,10 @@ namespace margelo::nitro::nitromodal {
       prototype.registerHybridSetter("onBackButtonPress", &HybridNitroModalSpec::setOnBackButtonPress);
       prototype.registerHybridGetter("onContentAreaChange", &HybridNitroModalSpec::getOnContentAreaChange);
       prototype.registerHybridSetter("onContentAreaChange", &HybridNitroModalSpec::setOnContentAreaChange);
+      prototype.registerHybridGetter("onPullToRefresh", &HybridNitroModalSpec::getOnPullToRefresh);
+      prototype.registerHybridSetter("onPullToRefresh", &HybridNitroModalSpec::setOnPullToRefresh);
+      prototype.registerHybridGetter("onRestingTopChange", &HybridNitroModalSpec::getOnRestingTopChange);
+      prototype.registerHybridSetter("onRestingTopChange", &HybridNitroModalSpec::setOnRestingTopChange);
       prototype.registerHybridMethod("present", &HybridNitroModalSpec::present);
       prototype.registerHybridMethod("dismiss", &HybridNitroModalSpec::dismiss);
       prototype.registerHybridMethod("snapToDetent", &HybridNitroModalSpec::snapToDetent);

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

@@ -15,8 +15,8 @@
 
 // Forward declaration of `ModalMode` to properly resolve imports.
 namespace margelo::nitro::nitromodal { enum class ModalMode; }
-// Forward declaration of `SheetDetent` to properly resolve imports.
-namespace margelo::nitro::nitromodal { enum class SheetDetent; }
+// Forward declaration of `NamedSheetDetent` to properly resolve imports.
+namespace margelo::nitro::nitromodal { enum class NamedSheetDetent; }
 // Forward declaration of `KeyboardBehavior` to properly resolve imports.
 namespace margelo::nitro::nitromodal { enum class KeyboardBehavior; }
 // Forward declaration of `PopupAnimation` to properly resolve imports.
@@ -27,7 +27,8 @@ namespace margelo::nitro::nitromodal { enum class DismissReason; }
 namespace margelo::nitro::nitromodal { struct ModalContentArea; }
 
 #include "ModalMode.hpp"
-#include "SheetDetent.hpp"
+#include "NamedSheetDetent.hpp"
+#include <variant>
 #include <vector>
 #include <optional>
 #include "KeyboardBehavior.hpp"
@@ -67,8 +68,10 @@ namespace margelo::nitro::nitromodal {
       virtual void setIsOpen(bool isOpen) = 0;
       virtual ModalMode getMode() = 0;
       virtual void setMode(ModalMode mode) = 0;
-      virtual std::vector<SheetDetent> getDetents() = 0;
-      virtual void setDetents(const std::vector<SheetDetent>& detents) = 0;
+      virtual bool getIsInline() = 0;
+      virtual void setIsInline(bool isInline) = 0;
+      virtual std::vector<std::variant<NamedSheetDetent, double>> getDetents() = 0;
+      virtual void setDetents(const std::vector<std::variant<NamedSheetDetent, double>>& detents) = 0;
       virtual double getInitialDetentIndex() = 0;
       virtual void setInitialDetentIndex(double initialDetentIndex) = 0;
       virtual double getBackdropColor() = 0;
@@ -93,6 +96,12 @@ namespace margelo::nitro::nitromodal {
       virtual void setKeyboardBehavior(KeyboardBehavior keyboardBehavior) = 0;
       virtual PopupAnimation getPopupAnimation() = 0;
       virtual void setPopupAnimation(PopupAnimation popupAnimation) = 0;
+      virtual bool getPullToRefreshEnabled() = 0;
+      virtual void setPullToRefreshEnabled(bool pullToRefreshEnabled) = 0;
+      virtual std::optional<bool> getRefreshing() = 0;
+      virtual void setRefreshing(std::optional<bool> refreshing) = 0;
+      virtual std::optional<double> getRefreshIndicatorColor() = 0;
+      virtual void setRefreshIndicatorColor(std::optional<double> refreshIndicatorColor) = 0;
       virtual std::optional<std::function<void()>> getOnPresent() = 0;
       virtual void setOnPresent(const std::optional<std::function<void()>>& onPresent) = 0;
       virtual std::optional<std::function<void(DismissReason /* reason */)>> getOnDismiss() = 0;
@@ -105,6 +114,10 @@ namespace margelo::nitro::nitromodal {
       virtual void setOnBackButtonPress(const std::optional<std::function<void()>>& onBackButtonPress) = 0;
       virtual std::optional<std::function<void(const ModalContentArea& /* area */)>> getOnContentAreaChange() = 0;
       virtual void setOnContentAreaChange(const std::optional<std::function<void(const ModalContentArea& /* area */)>>& onContentAreaChange) = 0;
+      virtual std::optional<std::function<void()>> getOnPullToRefresh() = 0;
+      virtual void setOnPullToRefresh(const std::optional<std::function<void()>>& onPullToRefresh) = 0;
+      virtual std::optional<std::function<void(double /* top */)>> getOnRestingTopChange() = 0;
+      virtual void setOnRestingTopChange(const std::optional<std::function<void(double /* top */)>>& onRestingTopChange) = 0;
 
     public:
       // Methods

package/nitrogen/generated/shared/c++/{SheetDetent.hpp → NamedSheetDetent.hpp}

@@ -1,5 +1,5 @@
 ///
-/// SheetDetent.hpp
+/// NamedSheetDetent.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -26,9 +26,9 @@
 namespace margelo::nitro::nitromodal {
 
   /**
-   * An enum which can be represented as a JavaScript union (SheetDetent).
+   * An enum which can be represented as a JavaScript union (NamedSheetDetent).
    */
-  enum class SheetDetent {
+  enum class NamedSheetDetent {
     SMALL      SWIFT_NAME(small) = 0,
     MEDIUM      SWIFT_NAME(medium) = 1,
     LARGE      SWIFT_NAME(large) = 2,
@@ -39,28 +39,28 @@ namespace margelo::nitro::nitromodal {
 
 namespace margelo::nitro {
 
-  // C++ SheetDetent <> JS SheetDetent (union)
+  // C++ NamedSheetDetent <> JS NamedSheetDetent (union)
   template <>
-  struct JSIConverter<margelo::nitro::nitromodal::SheetDetent> final {
-    static inline margelo::nitro::nitromodal::SheetDetent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::nitromodal::NamedSheetDetent> final {
+    static inline margelo::nitro::nitromodal::NamedSheetDetent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("small"): return margelo::nitro::nitromodal::SheetDetent::SMALL;
-        case hashString("medium"): return margelo::nitro::nitromodal::SheetDetent::MEDIUM;
-        case hashString("large"): return margelo::nitro::nitromodal::SheetDetent::LARGE;
-        case hashString("fitContent"): return margelo::nitro::nitromodal::SheetDetent::FITCONTENT;
+        case hashString("small"): return margelo::nitro::nitromodal::NamedSheetDetent::SMALL;
+        case hashString("medium"): return margelo::nitro::nitromodal::NamedSheetDetent::MEDIUM;
+        case hashString("large"): return margelo::nitro::nitromodal::NamedSheetDetent::LARGE;
+        case hashString("fitContent"): return margelo::nitro::nitromodal::NamedSheetDetent::FITCONTENT;
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum SheetDetent - invalid value!");
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NamedSheetDetent - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitromodal::SheetDetent arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitromodal::NamedSheetDetent arg) {
       switch (arg) {
-        case margelo::nitro::nitromodal::SheetDetent::SMALL: return JSIConverter<std::string>::toJSI(runtime, "small");
-        case margelo::nitro::nitromodal::SheetDetent::MEDIUM: return JSIConverter<std::string>::toJSI(runtime, "medium");
-        case margelo::nitro::nitromodal::SheetDetent::LARGE: return JSIConverter<std::string>::toJSI(runtime, "large");
-        case margelo::nitro::nitromodal::SheetDetent::FITCONTENT: return JSIConverter<std::string>::toJSI(runtime, "fitContent");
+        case margelo::nitro::nitromodal::NamedSheetDetent::SMALL: return JSIConverter<std::string>::toJSI(runtime, "small");
+        case margelo::nitro::nitromodal::NamedSheetDetent::MEDIUM: return JSIConverter<std::string>::toJSI(runtime, "medium");
+        case margelo::nitro::nitromodal::NamedSheetDetent::LARGE: return JSIConverter<std::string>::toJSI(runtime, "large");
+        case margelo::nitro::nitromodal::NamedSheetDetent::FITCONTENT: return JSIConverter<std::string>::toJSI(runtime, "fitContent");
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert SheetDetent to JS - invalid value: "
+          throw std::invalid_argument("Cannot convert NamedSheetDetent to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
       }
     }

package/nitrogen/generated/shared/c++/views/HybridNitroModalComponent.cpp

@@ -22,7 +22,8 @@ namespace margelo::nitro::nitromodal::views {
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
     isOpen(nitro::ReactProp<bool>::fromRawValue("NitroModal", "isOpen", rawProps, sourceProps.isOpen)),
     mode(nitro::ReactProp<ModalMode>::fromRawValue("NitroModal", "mode", rawProps, sourceProps.mode)),
-    detents(nitro::ReactProp<std::vector<SheetDetent>>::fromRawValue("NitroModal", "detents", rawProps, sourceProps.detents)),
+    isInline(nitro::ReactProp<bool>::fromRawValue("NitroModal", "isInline", rawProps, sourceProps.isInline)),
+    detents(nitro::ReactProp<std::vector<std::variant<NamedSheetDetent, double>>>::fromRawValue("NitroModal", "detents", rawProps, sourceProps.detents)),
     initialDetentIndex(nitro::ReactProp<double>::fromRawValue("NitroModal", "initialDetentIndex", rawProps, sourceProps.initialDetentIndex)),
     backdropColor(nitro::ReactProp<double>::fromRawValue("NitroModal", "backdropColor", rawProps, sourceProps.backdropColor)),
     backdropOpacity(nitro::ReactProp<double>::fromRawValue("NitroModal", "backdropOpacity", rawProps, sourceProps.backdropOpacity)),
@@ -35,18 +36,24 @@ namespace margelo::nitro::nitromodal::views {
     contentBackgroundColor(nitro::ReactProp<std::optional<double>>::fromRawValue("NitroModal", "contentBackgroundColor", rawProps, sourceProps.contentBackgroundColor)),
     keyboardBehavior(nitro::ReactProp<KeyboardBehavior>::fromRawValue("NitroModal", "keyboardBehavior", rawProps, sourceProps.keyboardBehavior)),
     popupAnimation(nitro::ReactProp<PopupAnimation>::fromRawValue("NitroModal", "popupAnimation", rawProps, sourceProps.popupAnimation)),
+    pullToRefreshEnabled(nitro::ReactProp<bool>::fromRawValue("NitroModal", "pullToRefreshEnabled", rawProps, sourceProps.pullToRefreshEnabled)),
+    refreshing(nitro::ReactProp<std::optional<bool>>::fromRawValue("NitroModal", "refreshing", rawProps, sourceProps.refreshing)),
+    refreshIndicatorColor(nitro::ReactProp<std::optional<double>>::fromRawValue("NitroModal", "refreshIndicatorColor", rawProps, sourceProps.refreshIndicatorColor)),
     onPresent(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("NitroModal", "onPresent", rawProps, sourceProps.onPresent)),
     onDismiss(nitro::ReactProp<std::optional<std::function<void(DismissReason /* reason */)>>>::fromRawValue("NitroModal", "onDismiss", rawProps, sourceProps.onDismiss)),
     onDetentChange(nitro::ReactProp<std::optional<std::function<void(double /* index */)>>>::fromRawValue("NitroModal", "onDetentChange", rawProps, sourceProps.onDetentChange)),
     onBackdropPress(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("NitroModal", "onBackdropPress", rawProps, sourceProps.onBackdropPress)),
     onBackButtonPress(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("NitroModal", "onBackButtonPress", rawProps, sourceProps.onBackButtonPress)),
     onContentAreaChange(nitro::ReactProp<std::optional<std::function<void(const ModalContentArea& /* area */)>>>::fromRawValue("NitroModal", "onContentAreaChange", rawProps, sourceProps.onContentAreaChange)),
+    onPullToRefresh(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("NitroModal", "onPullToRefresh", rawProps, sourceProps.onPullToRefresh)),
+    onRestingTopChange(nitro::ReactProp<std::optional<std::function<void(double /* top */)>>>::fromRawValue("NitroModal", "onRestingTopChange", rawProps, sourceProps.onRestingTopChange)),
     hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroModalSpec>& /* ref */)>>>::fromRawValue("NitroModal", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridNitroModalProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
       case hashString("isOpen"): return true;
       case hashString("mode"): return true;
+      case hashString("isInline"): return true;
       case hashString("detents"): return true;
       case hashString("initialDetentIndex"): return true;
       case hashString("backdropColor"): return true;
@@ -60,12 +67,17 @@ namespace margelo::nitro::nitromodal::views {
       case hashString("contentBackgroundColor"): return true;
       case hashString("keyboardBehavior"): return true;
       case hashString("popupAnimation"): return true;
+      case hashString("pullToRefreshEnabled"): return true;
+      case hashString("refreshing"): return true;
+      case hashString("refreshIndicatorColor"): return true;
       case hashString("onPresent"): return true;
       case hashString("onDismiss"): return true;
       case hashString("onDetentChange"): return true;
       case hashString("onBackdropPress"): return true;
       case hashString("onBackButtonPress"): return true;
       case hashString("onContentAreaChange"): return true;
+      case hashString("onPullToRefresh"): return true;
+      case hashString("onRestingTopChange"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

package/nitrogen/generated/shared/c++/views/HybridNitroModalComponent.hpp

@@ -18,7 +18,8 @@
 #include <string>
 
 #include "ModalMode.hpp"
-#include "SheetDetent.hpp"
+#include "NamedSheetDetent.hpp"
+#include <variant>
 #include <vector>
 #include <optional>
 #include "KeyboardBehavior.hpp"
@@ -51,7 +52,8 @@ namespace margelo::nitro::nitromodal::views {
   public:
     nitro::ReactProp<bool> isOpen;
     nitro::ReactProp<ModalMode> mode;
-    nitro::ReactProp<std::vector<SheetDetent>> detents;
+    nitro::ReactProp<bool> isInline;
+    nitro::ReactProp<std::vector<std::variant<NamedSheetDetent, double>>> detents;
     nitro::ReactProp<double> initialDetentIndex;
     nitro::ReactProp<double> backdropColor;
     nitro::ReactProp<double> backdropOpacity;
@@ -64,18 +66,24 @@ namespace margelo::nitro::nitromodal::views {
     nitro::ReactProp<std::optional<double>> contentBackgroundColor;
     nitro::ReactProp<KeyboardBehavior> keyboardBehavior;
     nitro::ReactProp<PopupAnimation> popupAnimation;
+    nitro::ReactProp<bool> pullToRefreshEnabled;
+    nitro::ReactProp<std::optional<bool>> refreshing;
+    nitro::ReactProp<std::optional<double>> refreshIndicatorColor;
     nitro::ReactProp<std::optional<std::function<void()>>> onPresent;
     nitro::ReactProp<std::optional<std::function<void(DismissReason /* reason */)>>> onDismiss;
     nitro::ReactProp<std::optional<std::function<void(double /* index */)>>> onDetentChange;
     nitro::ReactProp<std::optional<std::function<void()>>> onBackdropPress;
     nitro::ReactProp<std::optional<std::function<void()>>> onBackButtonPress;
     nitro::ReactProp<std::optional<std::function<void(const ModalContentArea& /* area */)>>> onContentAreaChange;
+    nitro::ReactProp<std::optional<std::function<void()>>> onPullToRefresh;
+    nitro::ReactProp<std::optional<std::function<void(double /* top */)>>> onRestingTopChange;
     nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroModalSpec>& /* ref */)>>> hybridRef;
 
     [[nodiscard]]
     bool hasSameProps(const HybridNitroModalProps& other) const noexcept {
       return isOpen.hasSameValue(other.isOpen) &&
              mode.hasSameValue(other.mode) &&
+             isInline.hasSameValue(other.isInline) &&
              detents.hasSameValue(other.detents) &&
              initialDetentIndex.hasSameValue(other.initialDetentIndex) &&
              backdropColor.hasSameValue(other.backdropColor) &&
@@ -89,12 +97,17 @@ namespace margelo::nitro::nitromodal::views {
              contentBackgroundColor.hasSameValue(other.contentBackgroundColor) &&
              keyboardBehavior.hasSameValue(other.keyboardBehavior) &&
              popupAnimation.hasSameValue(other.popupAnimation) &&
+             pullToRefreshEnabled.hasSameValue(other.pullToRefreshEnabled) &&
+             refreshing.hasSameValue(other.refreshing) &&
+             refreshIndicatorColor.hasSameValue(other.refreshIndicatorColor) &&
              onPresent.hasSameValue(other.onPresent) &&
              onDismiss.hasSameValue(other.onDismiss) &&
              onDetentChange.hasSameValue(other.onDetentChange) &&
              onBackdropPress.hasSameValue(other.onBackdropPress) &&
              onBackButtonPress.hasSameValue(other.onBackButtonPress) &&
              onContentAreaChange.hasSameValue(other.onContentAreaChange) &&
+             onPullToRefresh.hasSameValue(other.onPullToRefresh) &&
+             onRestingTopChange.hasSameValue(other.onRestingTopChange) &&
              hybridRef.hasSameValue(other.hybridRef);
     }
 
@@ -102,6 +115,7 @@ namespace margelo::nitro::nitromodal::views {
     bool hasAnyProvidedProps() const noexcept {
       return isOpen.isProvided() ||
              mode.isProvided() ||
+             isInline.isProvided() ||
              detents.isProvided() ||
              initialDetentIndex.isProvided() ||
              backdropColor.isProvided() ||
@@ -115,12 +129,17 @@ namespace margelo::nitro::nitromodal::views {
              contentBackgroundColor.isProvided() ||
              keyboardBehavior.isProvided() ||
              popupAnimation.isProvided() ||
+             pullToRefreshEnabled.isProvided() ||
+             refreshing.isProvided() ||
+             refreshIndicatorColor.isProvided() ||
              onPresent.isProvided() ||
              onDismiss.isProvided() ||
              onDetentChange.isProvided() ||
              onBackdropPress.isProvided() ||
              onBackButtonPress.isProvided() ||
              onContentAreaChange.isProvided() ||
+             onPullToRefresh.isProvided() ||
+             onRestingTopChange.isProvided() ||
              hybridRef.isProvided();
     }
 

package/nitrogen/generated/shared/json/NitroModalConfig.json

@@ -6,6 +6,7 @@
   "validAttributes": {
     "isOpen": true,
     "mode": true,
+    "isInline": true,
     "detents": true,
     "initialDetentIndex": true,
     "backdropColor": true,
@@ -19,12 +20,17 @@
     "contentBackgroundColor": true,
     "keyboardBehavior": true,
     "popupAnimation": true,
+    "pullToRefreshEnabled": true,
+    "refreshing": true,
+    "refreshIndicatorColor": true,
     "onPresent": true,
     "onDismiss": true,
     "onDetentChange": true,
     "onBackdropPress": true,
     "onBackButtonPress": true,
     "onContentAreaChange": true,
+    "onPullToRefresh": true,
+    "onRestingTopChange": true,
     "hybridRef": true
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modal",
-  "version": "0.2.0",
+  "version": "0.3.1-rc",
   "description": "react native native modal",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",