aix 0.3.1 → 0.4.0

package/README.md

@@ -1,32 +1,12 @@
-<img src="https://github.com/vercel/aix/blob/main/Aix.png?raw=true"
-alt="aix" width="1600" height="900" />
+# aix
 
-# AIX
+Primitives for building beautiful AI chat apps with React Native.
 
-UI Primitives for building AI apps in React Native.
+> aix is currently in alpha preview. The API will change, and it is not yet feature complete.
 
-## Features
+We're rewriting the engine that powers the chat experience in the v0 mobile app with a focus on native feel.
 
-- Start a chat scrolled to end on the first frame
-- Animate scrolling to new messages when they send
-- Float messages to the top of the screen with automated "blank size" handling
-- Animate message content as it streams
-- Keyboard handling out-of-the-box with no external dependencies
-- Support for absolute-positioned composers
-- Detect "is scrolled near end" for ScrollToEnd buttons
-
-To learn about the motivation behind AIX, you can read our blog post on
-[How we built the v0 iOS app](https://vercel.com/blog/how-we-built-the-v0-ios-app).
-AIX is an opinionated, feature-complete, and extensible way to implement every
-single feature mentioned in that blog post.
-
-When building AIX, we started by copying the code from v0 into a separate
-repository. However, as we worked to make it flexible for use cases outside of
-our own app, we decided to rewrite it from scratch in native code. What you see
-here is a Nitro Module which handles all business logic in UIKit. We plan on
-adding support for Android as well and welcome contributions.
-
-> aix is currently in alpha preview. The API may change.
+aix is a native module with UIKit with Nitro Modules.
 
 ## Installation
 
@@ -34,195 +14,133 @@ adding support for Android as well and welcome contributions.
 npm i aix react-native-nitro-modules
 ```
 
-Next, rebuild your native app. For Expo users, run `npx expo prebuild` and
-rebuild.
-
-- For a full example, see the [example app](./react-native-aix/example/App.tsx).
+Next, rebuild your native app. For Expo users, run `npx expo prebuild` and rebuild.
 
 ## Usage
 
 Wrap your `ScrollView` with `Aix`, and wrap your messages with `AixCell`.
 
+<details>
+  <summary>Click here to view a full example</summary>
+</details>
+
 ```tsx
-import { Aix, AixCell } from 'aix'
-import { Message } from 'path/to/your/message'
-import { Composer } from 'path/to/your/composer'
+import { Aix, AixCell } from 'aix';
+import { Message } from 'path/to/your/message';
+import { Composer } from 'path/to/your/composer';
 
 export function ChatScreen({ messages }) {
   return (
-    <Aix style={{ flex: 1 }} shouldStartAtEnd>
+    <Aix style={{ flex: 1 }}>
       <ScrollView>
         {messages.map((message) => (
-          <AixCell key={message.id} index={index} isLast={index === messages.length - 1}>
+          <AixCell
+            key={message.id}
+            index={index}
+            isLast={index === messages.length - 1}
+          >
             <Message message={message} />
           </AixCell>
         ))}
       </ScrollView>
     </Aix>
-  )
+  );
 }
 ```
 
-### Add a floating composer
-
-To add a floating composer which lets content scroll under it, you can use the
-`AixFooter`. Pair it with `Aix.scrollOnFooterSizeUpdate` to ensure content
-scrolls under the footer when it changes size.
+To add a floating composer which lets content scroll under it, you can use the `AixFooter` and `KeyboardStickyView` from `react-native-keyboard-controller`:
 
 ```tsx
-import { Aix, AixCell, AixFooter } from 'aix'
+import { Aix, AixCell, AixFooter } from 'aix';
+import { KeyboardStickyView } from 'react-native-keyboard-controller';
 
 export function ChatScreen({ messages }) {
-  const { bottom } = useSafeAreaInsets()
-
   return (
-    <Aix
-      style={{ flex: 1 }}
-      shouldStartAtEnd
-      scrollOnFooterSizeUpdate={{
-        enabled: true,
-        scrolledToEndThreshold: 100,
-        animated: false,
-      }}
-    >
+    <Aix style={{ flex: 1 }}>
       <ScrollView>
         {messages.map((message) => (
-          <AixCell key={message.id} index={index} isLast={index === messages.length - 1}>
+          <AixCell
+            key={message.id}
+            index={index}
+            isLast={index === messages.length - 1}
+          >
             <Message message={message} />
           </AixCell>
         ))}
       </ScrollView>
 
-      <AixFooter
-        style={{ position: 'absolute', inset: 0, top: 'auto' }}
-        stickToKeyboard={{
-          enabled: true,
-          offset: {
-            whenKeyboardOpen: 0,
-            whenKeyboardClosed: -bottom,
-          },
-        }}
-      >
-        <Composer />
-      </AixFooter>
+      <KeyboardStickyView offset={{ opened: 0, closed: -bottomInsetPadding }}>
+        <AixFooter style={{ position: 'absolute', inset: 0, top: 'auto'}}>
+          <Composer />
+        </AixFooter>
+      </KeyboardStickyView>
     </Aix>
-  )
-}
-```
-
-### Send a message
-
-When sending a message, you will likely want to scroll to it after it gets added
-to the list.
-
-Simply call `aix.current?.scrollToIndexWhenBlankSizeReady(index)` in your submit
-handler.
-
-The `index` you pass should correspond to the newest message in the list. For AI
-chats, this is typically the next assistant message index.
-
-```tsx
-import { Keyboard } from 'react-native'
-import { useAixRef } from 'aix'
-
-function Chat() {
-  const aix = useAixRef()
-
-  const onSubmit = () => {
-    aix.current?.scrollToIndexWhenBlankSizeReady(messages.length + 1, true)
-    requestAnimationFrame(Keyboard.dismiss)
-  }
-
-  return <Aix ref={aix}>{/* ... */}</Aix>
+  );
 }
 ```
 
-### Add a scroll to end button
-
-You can use `onScrolledNearEndChange` to show a "scroll to end" button when the
-user scrolls away from the bottom:
-
-```tsx
-import { Aix, useAixRef } from 'aix'
-import { useState } from 'react'
-import { Button } from 'react-native'
-
-function Chat() {
-  const aix = useAixRef()
-  const [isNearEnd, setIsNearEnd] = useState(false)
-
-  return (
-    <Aix ref={aix} scrollEndReachedThreshold={200} onScrolledNearEndChange={setIsNearEnd}>
-      {/* ScrollView and messages... */}
+## TODOs
 
-      {!isNearEnd && (
-        <Button onPress={() => aix.current?.scrollToEnd(true)} title='Scroll to end' />
-      )}
-    </Aix>
-  )
-}
-```
+- [ ] Android support
+- [ ] LegendList support
+- [ ] FlashList support
 
 ## API Reference
 
 ### `Aix`
 
-The main container component that provides keyboard-aware behavior and manages
-scrolling for chat interfaces.
+The main container component that provides keyboard-aware behavior and manages scrolling for chat interfaces.
 
 #### Props
 
-| Prop                              | Type                           | Default                                                           | Description                                                                                                                                                                                                                                                        |
-| --------------------------------- | ------------------------------ | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `shouldStartAtEnd`                | `boolean`                      | -                                                                 | Whether the scroll view should start scrolled to the end of the content.                                                                                                                                                                                           |
-| `scrollOnFooterSizeUpdate`        | `object`                       | `{ enabled: true, scrolledToEndThreshold: 100, animated: false }` | Control the behavior of scrolling when the footer size changes. By default, changing the height of the footer will shift content up in the scroll view.                                                                                                            |
-| `scrollEndReachedThreshold`       | `number`                       | `max(blankSize, 200)`                                             | The number of pixels from the bottom of the scroll view to the end of the content that is considered "near the end". Used by `onScrolledNearEndChange` and to determine if content should shift up when keyboard opens.                                            |
-| `onScrolledNearEndChange`         | `(isNearEnd: boolean) => void` | -                                                                 | Callback fired when the scroll position transitions between "near end" and "not near end" states. Reactive to user scrolling, content size changes, parent size changes, and keyboard height changes. Uses `scrollEndReachedThreshold` to determine the threshold. |
-| `additionalContentInsets`         | `object`                       | -                                                                 | Additional content insets applied when keyboard is open or closed. Shape: `{ top?: { whenKeyboardOpen, whenKeyboardClosed }, bottom?: { whenKeyboardOpen, whenKeyboardClosed } }`                                                                                  |
-| `additionalScrollIndicatorInsets` | `object`                       | -                                                                 | Additional insets for the scroll indicator, added to existing safe area insets. Applied to `verticalScrollIndicatorInsets` on iOS.                                                                                                                                 |
-| `mainScrollViewID`                | `string`                       | -                                                                 | The `nativeID` of the scroll view to use. If provided, will search for a scroll view with this `accessibilityIdentifier`.                                                                                                                                          |
-| `penultimateCellIndex`            | `number`                       | -                                                                 | The index of the second-to-last message (typically the last user message in AI chat apps). Used to determine which message will be scrolled into view. Useful when you have custom message types like timestamps in your list.                                     |
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `shouldStartAtEnd` | `boolean` | - | Whether the scroll view should start scrolled to the end of the content. |
+| `scrollOnFooterSizeUpdate` | `object` | `{ enabled: true, scrolledToEndThreshold: 100, animated: false }` | Control the behavior of scrolling when the footer size changes. By default, changing the height of the footer will shift content up in the scroll view. |
+| `scrollEndReachedThreshold` | `number` | `max(blankSize, 200)` | The number of pixels from the bottom of the scroll view to the end of the content that is considered "near the end". Used by `onScrolledNearEndChange` and to determine if content should shift up when keyboard opens. |
+| `onScrolledNearEndChange` | `(isNearEnd: boolean) => void` | - | Callback fired when the scroll position transitions between "near end" and "not near end" states. Reactive to user scrolling, content size changes, parent size changes, and keyboard height changes. Uses `scrollEndReachedThreshold` to determine the threshold. |
+| `additionalContentInsets` | `object` | - | Additional content insets applied when keyboard is open or closed. Shape: `{ top?: { whenKeyboardOpen, whenKeyboardClosed }, bottom?: { whenKeyboardOpen, whenKeyboardClosed } }` |
+| `additionalScrollIndicatorInsets` | `object` | - | Additional insets for the scroll indicator, added to existing safe area insets. Applied to `verticalScrollIndicatorInsets` on iOS. |
+| `mainScrollViewID` | `string` | - | The `nativeID` of the scroll view to use. If provided, will search for a scroll view with this `accessibilityIdentifier`. |
+| `penultimateCellIndex` | `number` | - | The index of the second-to-last message (typically the last user message in AI chat apps). Used to determine which message will be scrolled into view. Useful when you have custom message types like timestamps in your list. |
 
 #### Ref Methods
 
 Access these methods via `useAixRef()`:
 
 ```tsx
-const aix = useAixRef()
+const aix = useAixRef();
 
 // Scroll to the end of the content
-aix.current?.scrollToEnd(animated)
+aix.current?.scrollToEnd(animated);
 
 // Scroll to a specific index when the blank size is ready
-aix.current?.scrollToIndexWhenBlankSizeReady(index, animated, waitForKeyboardToEnd)
+aix.current?.scrollToIndexWhenBlankSizeReady(index, animated, waitForKeyboardToEnd);
 ```
 
-| Method                            | Parameters                                                          | Description                                                                |
-| --------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| `scrollToEnd`                     | `animated?: boolean`                                                | Scrolls to the end of the content.                                         |
+| Method | Parameters | Description |
+|--------|------------|-------------|
+| `scrollToEnd` | `animated?: boolean` | Scrolls to the end of the content. |
 | `scrollToIndexWhenBlankSizeReady` | `index: number, animated?: boolean, waitForKeyboardToEnd?: boolean` | Scrolls to a specific cell index once the blank size calculation is ready. |
 
 ---
 
 ### `AixCell`
 
-A wrapper component for each message in the list. It communicates cell position
-and dimensions to the parent `Aix` component.
+A wrapper component for each message in the list. It communicates cell position and dimensions to the parent `Aix` component.
 
 #### Props
 
-| Prop     | Type      | Required | Description                                                                                 |
-| -------- | --------- | -------- | ------------------------------------------------------------------------------------------- |
-| `index`  | `number`  | Yes      | The index of this cell in the message list.                                                 |
-| `isLast` | `boolean` | Yes      | Whether this cell is the last item in the list. Used for scroll positioning and animations. |
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `index` | `number` | Yes | The index of this cell in the message list. |
+| `isLast` | `boolean` | Yes | Whether this cell is the last item in the list. Used for scroll positioning and animations. |
 
 ---
 
 ### `AixFooter`
 
-A footer component for floating composers that allows content to scroll
-underneath it. The footer's height is automatically tracked for proper scroll
-offset calculations.
+A footer component for floating composers that allows content to scroll underneath it. The footer's height is automatically tracked for proper scroll offset calculations.
 
 #### Props
 
@@ -230,8 +148,7 @@ Accepts all standard React Native `View` props.
 
 #### Important Notes
 
-- **Do not apply vertical padding** (`padding`, `paddingBottom`) directly to
-  `AixFooter`. Apply padding to a child view instead.
+- **Do not apply vertical padding** (`padding`, `paddingBottom`) directly to `AixFooter`. Apply padding to a child view instead.
 - Position the footer absolutely at the bottom of the `Aix` container:
 
 ```tsx
@@ -247,32 +164,57 @@ Accepts all standard React Native `View` props.
 A hook that returns a ref to access imperative methods on the `Aix` component.
 
 ```tsx
-import { useAixRef } from 'aix'
+import { useAixRef } from 'aix';
 
 function Chat({ messages }) {
-  const aix = useAixRef()
+  const aix = useAixRef();
   const send = useSendMessage()
-
+  
   const handleSend = () => {
     // Scroll to end after sending a message
-    send(message)
-    aix.current?.scrollToIndexWhenBlankSizeReady(messages.length + 1, true)
-    requestAnimationFrame(Keyboard.dismiss)
-  }
-
-  return <Aix ref={aix}>{/* ... */}</Aix>
+    send(message);
+    aix.current?.scrollToIndexWhenBlankSizeReady(messages.length + 1, true);
+    requestAnimationFrame(Keyboard.dismiss);
+  };
+  
+  return <Aix ref={aix}>{/* ... */}</Aix>;
 }
 ```
 
 ---
 
+### Scroll to End Button
+
+You can use `onScrolledNearEndChange` to show a "scroll to end" button when the user scrolls away from the bottom:
+
+```tsx
+import { Aix, useAixRef } from 'aix';
+import { useState } from 'react';
+
+function Chat() {
+  const aix = useAixRef();
+  const [isNearEnd, setIsNearEnd] = useState(false);
+
+  return (
+    <Aix
+      ref={aix}
+      scrollEndReachedThreshold={200}
+      onScrolledNearEndChange={setIsNearEnd}
+    >
+      {/* ScrollView and messages... */}
+
+      {!isNearEnd && (
+        <Button onPress={() => aix.current?.scrollToEnd(true)} />
+      )}
+    </Aix>
+  );
+}
+```
+
 ## TODOs
 
-- [ ] Android support
-- [ ] LegendList support
-- [ ] FlashList support
 
 ## Requirements
 
 - React Native v0.78.0 or higher
-- Node 18.0.0 or higher
+- Node 18.0.0 or higher

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
 
@@ -448,23 +449,32 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         )
 
         print("[aix] applyContentInset \(targetBottom)")
+        onWillApplyContentInsets?(insets)
         
         // If shouldApplyContentInsets is explicitly false, call callback and return
         if shouldApplyContentInsets == false {
-            onWillApplyContentInsets?(insets)
             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":"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"}
+{"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.1",
+  "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.