aix 0.3.2 → 0.4.0

package/android/src/main/java/com/aix/HybridAix.kt

@@ -5,7 +5,7 @@ import android.view.View
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.uimanager.ThemedReactContext
-import com.margelo.nitro.aix.HybridAixSpec
+import com.margelo.nitro.aix.*
 
 @Keep
 @DoNotStrip
@@ -14,14 +14,24 @@ class HybridAix(val context: ThemedReactContext): HybridAixSpec() {
     override val view: View = View(context)
 
     // Props
-    private var _isRed = false
-    override var isRed: Boolean
-        get() = _isRed
-        set(value) {
-            _isRed = value
-            view.setBackgroundColor(
-                if (value) Color.RED
-                else Color.BLACK
-            )
-        }
+    override var shouldStartAtEnd: Boolean = true
+    override var scrollOnFooterSizeUpdate: AixScrollOnFooterSizeUpdate? = null
+    override var scrollEndReachedThreshold: Double? = null
+    override var additionalContentInsets: AixAdditionalContentInsetsProp? = null
+    override var additionalScrollIndicatorInsets: AixScrollIndicatorInsets? = null
+    override var mainScrollViewID: String? = null
+    override var penultimateCellIndex: Double? = null
+    override var shouldApplyContentInsets: Boolean? = null
+    override var applyContentInsetDelay: Double? = null
+    override var onWillApplyContentInsets: ((insets: AixContentInsets) -> Unit)? = null
+    override var onScrolledNearEndChange: ((isNearEnd: Boolean) -> Unit)? = null
+
+    // Methods
+    override fun scrollToEnd(animated: Boolean?) {
+        // TODO: Implement for Android
+    }
+
+    override fun scrollToIndexWhenBlankSizeReady(index: Double, animated: Boolean?, waitForKeyboardToEnd: Boolean?) {
+        // TODO: Implement for Android
+    }
 }

package/ios/HybridAix.swift

@@ -100,6 +100,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     var penultimateCellIndex: Double?
     
     var shouldApplyContentInsets: Bool? = nil
+    var applyContentInsetDelay: Double? = nil
     var onWillApplyContentInsets: ((_ insets: AixContentInsets) -> Void)? = nil
     var onScrolledNearEndChange: ((_ isNearEnd: Bool) -> Void)? = nil
 
@@ -455,16 +456,25 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             return
         }
         
-        // Default behavior: apply insets directly
-        if scrollView.contentInset.top != targetTop {
-            scrollView.contentInset.top = targetTop
-        }
-        if scrollView.contentInset.bottom != targetBottom {
-            scrollView.contentInset.bottom = targetBottom
+        // Helper to actually apply the insets
+        let applyInsets = { [weak self] in
+            guard let self, let scrollView = self.scrollView else { return }
+            if scrollView.contentInset.top != targetTop {
+                scrollView.contentInset.top = targetTop
+            }
+            if scrollView.contentInset.bottom != targetBottom {
+                scrollView.contentInset.bottom = targetBottom
+            }
+            // Update scrolled near end state after insets change
+            self.updateScrolledNearEndState()
         }
         
-        // Update scrolled near end state after insets change
-        updateScrolledNearEndState()
+        // Apply with optional delay
+        if let delay = applyContentInsetDelay, delay > 0 {
+            DispatchQueue.main.asyncAfter(deadline: .now() + delay / 1000.0, execute: applyInsets)
+        } else {
+            applyInsets()
+        }
     }
 
     /// Centralized function to check and fire onScrolledNearEndChange callback

package/lib/typescript/src/aix.d.ts

@@ -10,6 +10,7 @@ export declare const Aix: import("react").ForwardRefExoticComponent<Omit<{
     mainScrollViewID?: string | import("react-native-reanimated").SharedValue<string | undefined> | undefined;
     penultimateCellIndex?: number | import("react-native-reanimated").SharedValue<number | undefined> | undefined;
     shouldApplyContentInsets?: boolean | import("react-native-reanimated").SharedValue<boolean | undefined> | undefined;
+    applyContentInsetDelay?: number | import("react-native-reanimated").SharedValue<number | undefined> | undefined;
     onWillApplyContentInsets?: import("react-native-nitro-modules").NitroViewWrappedCallback<((insets: AixContentInsets) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((insets: AixContentInsets) => void) | undefined> | undefined> | undefined;
     onScrolledNearEndChange?: import("react-native-nitro-modules").NitroViewWrappedCallback<((isNearEnd: boolean) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((isNearEnd: boolean) => void) | undefined> | undefined> | undefined;
     hybridRef?: import("react-native-nitro-modules").NitroViewWrappedCallback<((ref: import("react-native-nitro-modules").HybridView<AixProps, AixMethods>) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((ref: import("react-native-nitro-modules").HybridView<AixProps, AixMethods>) => void) | undefined> | undefined> | undefined;
@@ -127,6 +128,7 @@ export declare const Aix: import("react").ForwardRefExoticComponent<Omit<{
         mainScrollViewID?: string | import("react-native-reanimated").SharedValue<string | undefined> | undefined;
         penultimateCellIndex?: number | import("react-native-reanimated").SharedValue<number | undefined> | undefined;
         shouldApplyContentInsets?: boolean | import("react-native-reanimated").SharedValue<boolean | undefined> | undefined;
+        applyContentInsetDelay?: number | import("react-native-reanimated").SharedValue<number | undefined> | undefined;
         onWillApplyContentInsets?: import("react-native-nitro-modules").NitroViewWrappedCallback<((insets: AixContentInsets) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((insets: AixContentInsets) => void) | undefined> | undefined> | undefined;
         onScrolledNearEndChange?: import("react-native-nitro-modules").NitroViewWrappedCallback<((isNearEnd: boolean) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((isNearEnd: boolean) => void) | undefined> | undefined> | undefined;
         hybridRef?: import("react-native-nitro-modules").NitroViewWrappedCallback<((ref: import("react-native-nitro-modules").HybridView<AixProps, AixMethods>) => void) | undefined> | import("react-native-reanimated").SharedValue<import("react-native-nitro-modules").NitroViewWrappedCallback<((ref: import("react-native-nitro-modules").HybridView<AixProps, AixMethods>) => void) | undefined> | undefined> | undefined;

package/lib/typescript/src/aix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aix.d.ts","sourceRoot":"","sources":["../../../src/aix.tsx"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,4BAA4B,CAAA;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAI/E,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;AAgBpD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAJa,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI;8BACnC,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI;0CAyCvD,CAAA"}
+{"version":3,"file":"aix.d.ts","sourceRoot":"","sources":["../../../src/aix.tsx"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,4BAA4B,CAAA;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAI/E,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;AAgBpD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAJa,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI;8BACnC,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI;0CAyCvD,CAAA"}

package/lib/typescript/src/views/aix.nitro.d.ts

@@ -104,6 +104,13 @@ export interface AixProps extends HybridViewProps {
      */
     penultimateCellIndex?: number;
     shouldApplyContentInsets?: boolean;
+    /**
+     * Optional delay in milliseconds before applying content insets to the scroll view.
+     *
+     * This can help work around race conditions where insets are applied before
+     * React commits layout changes.
+     */
+    applyContentInsetDelay?: number;
     onWillApplyContentInsets?: (insets: AixContentInsets) => void;
     /**
      * Called when the scroll position changes between "near end" and "not near end" states.

package/lib/typescript/src/views/aix.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aix.nitro.d.ts","sourceRoot":"","sources":["../../../../src/views/aix.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,EAAE,MAAM,CAAA;IACxB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,8BAA8B;IAC7C,GAAG,CAAC,EAAE,0BAA0B,CAAA;IAChC,MAAM,CAAC,EAAE,0BAA0B,CAAA;CACpC;AAED,MAAM,WAAW,4BAA4B;IAC3C,gBAAgB,EAAE,MAAM,CAAA;IACxB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,EAAE,4BAA4B,CAAA;IAClC,MAAM,CAAC,EAAE,4BAA4B,CAAA;CACtC;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,QAAS,SAAQ,eAAe;IAC/C,gBAAgB,EAAE,OAAO,CAAA;IACzB;;;;;;OAMG;IACH,wBAAwB,CAAC,EAAE,2BAA2B,CAAA;IACtD;;;;;;;;;OASG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;;;;;;;;;;OAYG;IAEH,uBAAuB,CAAC,EAAE,8BAA8B,CAAA;IAExD;;;OAGG;IACH,+BAA+B,CAAC,EAAE,wBAAwB,CAAA;IAE1D;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAE7B,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC,wBAAwB,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAA;IAC7D;;;OAGG;IACH,uBAAuB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAA;CACvD;AAED,MAAM,WAAW,UAAW,SAAQ,iBAAiB;IACnD,WAAW,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IACrC,+BAA+B,CAC7B,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,OAAO,EAClB,oBAAoB,CAAC,EAAE,OAAO,GAC7B,IAAI,CAAA;CACR;AAED,MAAM,MAAM,GAAG,GAAG,UAAU,CAC1B,QAAQ,EACR,UAAU,EACV;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CACpC,CAAA;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAClC,gBAAgB,EAChB,EAAE,EACF;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CACpC,CAAA;AAED,MAAM,WAAW,wBAAwB;IACvC,gBAAgB,EAAE,MAAM,CAAA;IACxB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,wBAAwB,CAAA;CAClC;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,eAAe,CAAC,EAAE,kBAAkB,CAAA;CACrC;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAClC,gBAAgB,EAChB,EAAE,EACF;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CACpC,CAAA"}
+{"version":3,"file":"aix.nitro.d.ts","sourceRoot":"","sources":["../../../../src/views/aix.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/android/c++/JHybridAixSpec.cpp

@@ -140,6 +140,15 @@ namespace margelo::nitro::aix {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* shouldApplyContentInsets */)>("setShouldApplyContentInsets");
     method(_javaPart, shouldApplyContentInsets.has_value() ? jni::JBoolean::valueOf(shouldApplyContentInsets.value()) : nullptr);
   }
+  std::optional<double> JHybridAixSpec::getApplyContentInsetDelay() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getApplyContentInsetDelay");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAixSpec::setApplyContentInsetDelay(std::optional<double> applyContentInsetDelay) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* applyContentInsetDelay */)>("setApplyContentInsetDelay");
+    method(_javaPart, applyContentInsetDelay.has_value() ? jni::JDouble::valueOf(applyContentInsetDelay.value()) : nullptr);
+  }
   std::optional<std::function<void(const AixContentInsets& /* insets */)>> JHybridAixSpec::getOnWillApplyContentInsets() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_AixContentInsets::javaobject>()>("getOnWillApplyContentInsets_cxx");
     auto __result = method(_javaPart);

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

@@ -66,6 +66,8 @@ namespace margelo::nitro::aix {
     void setPenultimateCellIndex(std::optional<double> penultimateCellIndex) override;
     std::optional<bool> getShouldApplyContentInsets() override;
     void setShouldApplyContentInsets(std::optional<bool> shouldApplyContentInsets) override;
+    std::optional<double> getApplyContentInsetDelay() override;
+    void setApplyContentInsetDelay(std::optional<double> applyContentInsetDelay) override;
     std::optional<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() override;
     void setOnWillApplyContentInsets(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& onWillApplyContentInsets) override;
     std::optional<std::function<void(bool /* isNearEnd */)>> getOnScrolledNearEndChange() override;

package/nitrogen/generated/android/c++/views/JHybridAixStateUpdater.cpp

@@ -68,6 +68,10 @@ void JHybridAixStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* clas
     view->setShouldApplyContentInsets(props.shouldApplyContentInsets.value);
     // TODO: Set isDirty = false
   }
+  if (props.applyContentInsetDelay.isDirty) {
+    view->setApplyContentInsetDelay(props.applyContentInsetDelay.value);
+    // TODO: Set isDirty = false
+  }
   if (props.onWillApplyContentInsets.isDirty) {
     view->setOnWillApplyContentInsets(props.onWillApplyContentInsets.value);
     // TODO: Set isDirty = false

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/HybridAixSpec.kt

@@ -90,6 +90,12 @@ abstract class HybridAixSpec: HybridView() {
   @set:Keep
   abstract var shouldApplyContentInsets: Boolean?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var applyContentInsetDelay: Double?
+  
   abstract var onWillApplyContentInsets: ((insets: AixContentInsets) -> Unit)?
   
   private var onWillApplyContentInsets_cxx: Func_void_AixContentInsets?

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

@@ -130,6 +130,13 @@ namespace margelo::nitro::aix {
     inline void setShouldApplyContentInsets(std::optional<bool> shouldApplyContentInsets) noexcept override {
       _swiftPart.setShouldApplyContentInsets(shouldApplyContentInsets);
     }
+    inline std::optional<double> getApplyContentInsetDelay() noexcept override {
+      auto __result = _swiftPart.getApplyContentInsetDelay();
+      return __result;
+    }
+    inline void setApplyContentInsetDelay(std::optional<double> applyContentInsetDelay) noexcept override {
+      _swiftPart.setApplyContentInsetDelay(applyContentInsetDelay);
+    }
     inline std::optional<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() noexcept override {
       auto __result = _swiftPart.getOnWillApplyContentInsets();
       return __result;

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

@@ -111,6 +111,11 @@ using namespace margelo::nitro::aix::views;
     swiftPart.setShouldApplyContentInsets(newViewProps.shouldApplyContentInsets.value);
     newViewProps.shouldApplyContentInsets.isDirty = false;
   }
+  // applyContentInsetDelay: optional
+  if (newViewProps.applyContentInsetDelay.isDirty) {
+    swiftPart.setApplyContentInsetDelay(newViewProps.applyContentInsetDelay.value);
+    newViewProps.applyContentInsetDelay.isDirty = false;
+  }
   // onWillApplyContentInsets: optional
   if (newViewProps.onWillApplyContentInsets.isDirty) {
     swiftPart.setOnWillApplyContentInsets(newViewProps.onWillApplyContentInsets.value);

package/nitrogen/generated/ios/swift/HybridAixSpec.swift

@@ -19,6 +19,7 @@ public protocol HybridAixSpec_protocol: HybridObject, HybridView {
   var mainScrollViewID: String? { get set }
   var penultimateCellIndex: Double? { get set }
   var shouldApplyContentInsets: Bool? { get set }
+  var applyContentInsetDelay: Double? { get set }
   var onWillApplyContentInsets: ((_ insets: AixContentInsets) -> Void)? { get set }
   var onScrolledNearEndChange: ((_ isNearEnd: Bool) -> Void)? { get set }
 

package/nitrogen/generated/ios/swift/HybridAixSpec_cxx.swift

@@ -258,6 +258,23 @@ open class HybridAixSpec_cxx {
     }
   }
   
+  public final var applyContentInsetDelay: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.applyContentInsetDelay {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.applyContentInsetDelay = newValue.value
+    }
+  }
+  
   public final var onWillApplyContentInsets: bridge.std__optional_std__function_void_const_AixContentInsets_____insets______ {
     @inline(__always)
     get {

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

@@ -30,6 +30,8 @@ namespace margelo::nitro::aix {
       prototype.registerHybridSetter("penultimateCellIndex", &HybridAixSpec::setPenultimateCellIndex);
       prototype.registerHybridGetter("shouldApplyContentInsets", &HybridAixSpec::getShouldApplyContentInsets);
       prototype.registerHybridSetter("shouldApplyContentInsets", &HybridAixSpec::setShouldApplyContentInsets);
+      prototype.registerHybridGetter("applyContentInsetDelay", &HybridAixSpec::getApplyContentInsetDelay);
+      prototype.registerHybridSetter("applyContentInsetDelay", &HybridAixSpec::setApplyContentInsetDelay);
       prototype.registerHybridGetter("onWillApplyContentInsets", &HybridAixSpec::getOnWillApplyContentInsets);
       prototype.registerHybridSetter("onWillApplyContentInsets", &HybridAixSpec::setOnWillApplyContentInsets);
       prototype.registerHybridGetter("onScrolledNearEndChange", &HybridAixSpec::getOnScrolledNearEndChange);

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

@@ -73,6 +73,8 @@ namespace margelo::nitro::aix {
       virtual void setPenultimateCellIndex(std::optional<double> penultimateCellIndex) = 0;
       virtual std::optional<bool> getShouldApplyContentInsets() = 0;
       virtual void setShouldApplyContentInsets(std::optional<bool> shouldApplyContentInsets) = 0;
+      virtual std::optional<double> getApplyContentInsetDelay() = 0;
+      virtual void setApplyContentInsetDelay(std::optional<double> applyContentInsetDelay) = 0;
       virtual std::optional<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() = 0;
       virtual void setOnWillApplyContentInsets(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& onWillApplyContentInsets) = 0;
       virtual std::optional<std::function<void(bool /* isNearEnd */)>> getOnScrolledNearEndChange() = 0;

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

@@ -105,6 +105,16 @@ namespace margelo::nitro::aix::views {
         throw std::runtime_error(std::string("Aix.shouldApplyContentInsets: ") + exc.what());
       }
     }()),
+    applyContentInsetDelay([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("applyContentInsetDelay", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.applyContentInsetDelay;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.applyContentInsetDelay);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.applyContentInsetDelay: ") + exc.what());
+      }
+    }()),
     onWillApplyContentInsets([&]() -> CachedProp<std::optional<std::function<void(const AixContentInsets& /* insets */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onWillApplyContentInsets", nullptr, nullptr);
@@ -146,6 +156,7 @@ namespace margelo::nitro::aix::views {
     mainScrollViewID(other.mainScrollViewID),
     penultimateCellIndex(other.penultimateCellIndex),
     shouldApplyContentInsets(other.shouldApplyContentInsets),
+    applyContentInsetDelay(other.applyContentInsetDelay),
     onWillApplyContentInsets(other.onWillApplyContentInsets),
     onScrolledNearEndChange(other.onScrolledNearEndChange),
     hybridRef(other.hybridRef) { }
@@ -160,6 +171,7 @@ namespace margelo::nitro::aix::views {
       case hashString("mainScrollViewID"): return true;
       case hashString("penultimateCellIndex"): return true;
       case hashString("shouldApplyContentInsets"): return true;
+      case hashString("applyContentInsetDelay"): return true;
       case hashString("onWillApplyContentInsets"): return true;
       case hashString("onScrolledNearEndChange"): return true;
       case hashString("hybridRef"): return true;

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

@@ -55,6 +55,7 @@ namespace margelo::nitro::aix::views {
     CachedProp<std::optional<std::string>> mainScrollViewID;
     CachedProp<std::optional<double>> penultimateCellIndex;
     CachedProp<std::optional<bool>> shouldApplyContentInsets;
+    CachedProp<std::optional<double>> applyContentInsetDelay;
     CachedProp<std::optional<std::function<void(const AixContentInsets& /* insets */)>>> onWillApplyContentInsets;
     CachedProp<std::optional<std::function<void(bool /* isNearEnd */)>>> onScrolledNearEndChange;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixSpec>& /* ref */)>>> hybridRef;

package/nitrogen/generated/shared/json/AixConfig.json

@@ -12,6 +12,7 @@
     "mainScrollViewID": true,
     "penultimateCellIndex": true,
     "shouldApplyContentInsets": true,
+    "applyContentInsetDelay": true,
     "onWillApplyContentInsets": true,
     "onScrolledNearEndChange": true,
     "hybridRef": true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aix",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "author": "Fernando Rojo",
   "repository": {
     "type": "git",

package/src/views/aix.nitro.ts

@@ -120,6 +120,13 @@ export interface AixProps extends HybridViewProps {
   penultimateCellIndex?: number
 
   shouldApplyContentInsets?: boolean
+  /**
+   * Optional delay in milliseconds before applying content insets to the scroll view.
+   * 
+   * This can help work around race conditions where insets are applied before
+   * React commits layout changes.
+   */
+  applyContentInsetDelay?: number
   onWillApplyContentInsets?: (insets: AixContentInsets) => void
   /**
    * Called when the scroll position changes between "near end" and "not near end" states.