aix 0.1.0-alpha.1 → 0.2.0

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

@@ -19,12 +19,16 @@ namespace margelo::nitro::aix { struct AixScrollOnFooterSizeUpdate; }
 namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
 // Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
+// Forward declaration of `AixContentInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixContentInsets; }
 
 #include "AixScrollOnFooterSizeUpdate.hpp"
 #include <optional>
 #include "AixAdditionalContentInsetsProp.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include <string>
+#include "AixContentInsets.hpp"
+#include <functional>
 
 namespace margelo::nitro::aix {
 
@@ -67,6 +71,10 @@ namespace margelo::nitro::aix {
       virtual void setMainScrollViewID(const std::optional<std::string>& mainScrollViewID) = 0;
       virtual std::optional<double> getPenultimateCellIndex() = 0;
       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<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() = 0;
+      virtual void setOnWillApplyContentInsets(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& onWillApplyContentInsets) = 0;
 
     public:
       // Methods

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

@@ -95,6 +95,26 @@ namespace margelo::nitro::aix::views {
         throw std::runtime_error(std::string("Aix.penultimateCellIndex: ") + exc.what());
       }
     }()),
+    shouldApplyContentInsets([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("shouldApplyContentInsets", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.shouldApplyContentInsets;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.shouldApplyContentInsets);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.shouldApplyContentInsets: ") + exc.what());
+      }
+    }()),
+    onWillApplyContentInsets([&]() -> CachedProp<std::optional<std::function<void(const AixContentInsets& /* insets */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onWillApplyContentInsets", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onWillApplyContentInsets;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const AixContentInsets& /* insets */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onWillApplyContentInsets);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.onWillApplyContentInsets: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -115,6 +135,8 @@ namespace margelo::nitro::aix::views {
     additionalScrollIndicatorInsets(other.additionalScrollIndicatorInsets),
     mainScrollViewID(other.mainScrollViewID),
     penultimateCellIndex(other.penultimateCellIndex),
+    shouldApplyContentInsets(other.shouldApplyContentInsets),
+    onWillApplyContentInsets(other.onWillApplyContentInsets),
     hybridRef(other.hybridRef) { }
 
   bool HybridAixProps::filterObjectKeys(const std::string& propName) {
@@ -126,6 +148,8 @@ namespace margelo::nitro::aix::views {
       case hashString("additionalScrollIndicatorInsets"): return true;
       case hashString("mainScrollViewID"): return true;
       case hashString("penultimateCellIndex"): return true;
+      case hashString("shouldApplyContentInsets"): return true;
+      case hashString("onWillApplyContentInsets"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

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

@@ -21,9 +21,10 @@
 #include "AixAdditionalContentInsetsProp.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include <string>
+#include "AixContentInsets.hpp"
+#include <functional>
 #include <memory>
 #include "HybridAixSpec.hpp"
-#include <functional>
 
 namespace margelo::nitro::aix::views {
 
@@ -53,6 +54,8 @@ namespace margelo::nitro::aix::views {
     CachedProp<std::optional<AixScrollIndicatorInsets>> additionalScrollIndicatorInsets;
     CachedProp<std::optional<std::string>> mainScrollViewID;
     CachedProp<std::optional<double>> penultimateCellIndex;
+    CachedProp<std::optional<bool>> shouldApplyContentInsets;
+    CachedProp<std::optional<std::function<void(const AixContentInsets& /* insets */)>>> onWillApplyContentInsets;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixSpec>& /* ref */)>>> hybridRef;
 
   private:

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

@@ -11,6 +11,8 @@
     "additionalScrollIndicatorInsets": true,
     "mainScrollViewID": true,
     "penultimateCellIndex": true,
+    "shouldApplyContentInsets": true,
+    "onWillApplyContentInsets": true,
     "hybridRef": true
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aix",
-  "version": "0.1.0-alpha.1",
+  "version": "0.2.0",
   "author": "Fernando Rojo",
   "repository": {
     "type": "git",
@@ -19,6 +19,7 @@
     "react-native": "0.82",
     "react-native-builder-bob": "^0.37.0",
     "react-native-nitro-modules": "0.31.10",
+    "react-native-reanimated": "^3.17.0",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "semantic-release": "^24.2.9",
     "typescript": "^5.8.3"
@@ -26,7 +27,8 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "*"
+    "react-native-nitro-modules": "*",
+    "react-native-reanimated": ">=3.0.0"
   },
   "bugs": "https://github.com/vercel/aix/issues",
   "description": "aix is a react native package built with Nitro",

package/src/aix.tsx

@@ -4,17 +4,26 @@ import {
   type HybridRef,
 } from 'react-native-nitro-modules'
 import AixConfig from '../nitrogen/generated/shared/json/AixConfig.json'
-import type { AixProps, AixMethods } from './views/aix.nitro'
-import { forwardRef } from 'react'
+import type { AixProps, AixMethods, AixContentInsets } from './views/aix.nitro'
+import { forwardRef, type ComponentProps } from 'react'
+import Animated from 'react-native-reanimated'
 
 export type AixRef = HybridRef<AixProps, AixMethods>
 
-const AixInternal = getHostComponent<AixProps, AixMethods>(
+const AixInternal = Animated.createAnimatedComponent(getHostComponent<AixProps, AixMethods>(
   'Aix',
   () => AixConfig
-)
+))
+
+// User-facing props type that accepts regular functions (not wrapped callbacks)
+type AixComponentProps = Omit<
+  ComponentProps<typeof AixInternal>,
+  'onWillApplyContentInsets' | 'hybridRef'
+> & {
+  onWillApplyContentInsets?: (insets: AixContentInsets) => void
+}
 
-export const Aix = forwardRef<AixRef, React.ComponentProps<typeof AixInternal>>(
+export const Aix = forwardRef<AixRef, AixComponentProps>(
   function Aix(props, ref) {
     return (
       <AixInternal
@@ -26,15 +35,21 @@ export const Aix = forwardRef<AixRef, React.ComponentProps<typeof AixInternal>>(
             animated: false,
           }
         }
+        // Wrap onWillApplyContentInsets with callback() if provided
+        onWillApplyContentInsets={
+          props.onWillApplyContentInsets
+            ? callback(props.onWillApplyContentInsets)
+            : undefined
+        }
         hybridRef={
           ref
             ? callback((r) => {
-                if (typeof ref === 'function') {
-                  ref(r)
-                } else {
-                  ref.current = r
-                }
-              })
+              if (typeof ref === 'function') {
+                ref(r)
+              } else {
+                ref.current = r
+              }
+            })
             : undefined
         }
       />

package/src/hooks/useContentInsetHandler.ts

@@ -0,0 +1,28 @@
+import { useCallback } from 'react'
+import type { AixContentInsets } from '../views/aix.nitro'
+
+/**
+ * Hook that creates a stable callback handler for content inset updates.
+ * Use this with `onWillApplyContentInsets` prop to receive inset updates.
+ *
+ * @example
+ * ```tsx
+ * const bottomInset = useSharedValue<number | null>(null)
+ *
+ * const contentInsetHandler = useContentInsetHandler((insets) => {
+ *   bottomInset.value = insets.bottom ?? null
+ * })
+ *
+ * <Aix
+ *   shouldApplyContentInsets={false}
+ *   onWillApplyContentInsets={contentInsetHandler}
+ * />
+ * ```
+ */
+export function useContentInsetHandler(
+  handler: (insets: AixContentInsets) => void,
+  dependencies: unknown[] = []
+) {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useCallback(handler, dependencies)
+}

package/src/index.ts

@@ -7,6 +7,8 @@ export * from './fade-in'
 
 export { Aix, type AixRef } from './aix'
 export { AixFooter } from './footer'
+export { useContentInsetHandler } from './hooks/useContentInsetHandler'
+export type { AixContentInsets } from './views/aix.nitro'
 
 export const AixCell = getHostComponent<AixCellViewProps, {}>(
   'AixCellView',

package/src/views/aix.nitro.ts

@@ -45,6 +45,13 @@ export interface AixScrollOnFooterSizeUpdate {
   animated?: boolean
 }
 
+export interface AixContentInsets {
+  top?: number
+  left?: number
+  bottom?: number
+  right?: number
+}
+
 export interface AixProps extends HybridViewProps {
   shouldStartAtEnd: boolean
   /**
@@ -111,6 +118,9 @@ export interface AixProps extends HybridViewProps {
    *
    */
   penultimateCellIndex?: number
+
+  shouldApplyContentInsets?: boolean
+  onWillApplyContentInsets?: (insets: AixContentInsets) => void
 }
 
 export interface AixMethods extends HybridViewMethods {