aix 0.0.14 → 0.1.0-alpha.1

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

@@ -0,0 +1,117 @@
+///
+/// HybridAixComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include "AixScrollOnFooterSizeUpdate.hpp"
+#include <optional>
+#include "AixAdditionalContentInsetsProp.hpp"
+#include "AixScrollIndicatorInsets.hpp"
+#include <string>
+#include <memory>
+#include "HybridAixSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::aix::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAixComponentName[];
+
+  /**
+   * Props for the "Aix" View.
+   */
+  class HybridAixProps final: public react::ViewProps {
+  public:
+    HybridAixProps() = default;
+    HybridAixProps(const HybridAixProps&);
+    HybridAixProps(const react::PropsParserContext& context,
+                   const HybridAixProps& sourceProps,
+                   const react::RawProps& rawProps);
+
+  public:
+    CachedProp<bool> shouldStartAtEnd;
+    CachedProp<std::optional<AixScrollOnFooterSizeUpdate>> scrollOnFooterSizeUpdate;
+    CachedProp<std::optional<double>> scrollEndReachedThreshold;
+    CachedProp<std::optional<AixAdditionalContentInsetsProp>> additionalContentInsets;
+    CachedProp<std::optional<AixScrollIndicatorInsets>> additionalScrollIndicatorInsets;
+    CachedProp<std::optional<std::string>> mainScrollViewID;
+    CachedProp<std::optional<double>> penultimateCellIndex;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "Aix" View.
+   */
+  class HybridAixState final {
+  public:
+    HybridAixState() = default;
+
+  public:
+    void setProps(const HybridAixProps& props) { _props.emplace(props); }
+    const std::optional<HybridAixProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAixState(const HybridAixState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAixState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAixState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAixProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "Aix" View.
+   */
+  using HybridAixShadowNode = react::ConcreteViewShadowNode<HybridAixComponentName /* "HybridAix" */,
+                                                            HybridAixProps /* custom props */,
+                                                            react::ViewEventEmitter /* default */,
+                                                            HybridAixState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "Aix" View.
+   */
+  class HybridAixComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAixShadowNode> {
+  public:
+    HybridAixComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAixProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "Aix" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,75 @@
+///
+/// HybridAixComposerComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixComposerComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::aix::views {
+
+  extern const char HybridAixComposerComponentName[] = "AixComposer";
+
+  HybridAixComposerProps::HybridAixComposerProps(const react::PropsParserContext& context,
+                                                 const HybridAixComposerProps& sourceProps,
+                                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixComposerSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixComposerSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixComposer.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAixComposerProps::HybridAixComposerProps(const HybridAixComposerProps& other):
+    react::ViewProps(),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAixComposerProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAixComposerComponentDescriptor::HybridAixComposerComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAixComposerComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                       const std::shared_ptr<const react::Props>& props,
+                                                                                       react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridAixComposerShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAixComposerComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<HybridAixComposerShadowNode&>(shadowNode);
+    const HybridAixComposerProps& props = concreteShadowNode.getConcreteProps();
+    HybridAixComposerState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,106 @@
+///
+/// HybridAixComposerComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <memory>
+#include "HybridAixComposerSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::aix::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAixComposerComponentName[];
+
+  /**
+   * Props for the "AixComposer" View.
+   */
+  class HybridAixComposerProps final: public react::ViewProps {
+  public:
+    HybridAixComposerProps() = default;
+    HybridAixComposerProps(const HybridAixComposerProps&);
+    HybridAixComposerProps(const react::PropsParserContext& context,
+                           const HybridAixComposerProps& sourceProps,
+                           const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixComposerSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "AixComposer" View.
+   */
+  class HybridAixComposerState final {
+  public:
+    HybridAixComposerState() = default;
+
+  public:
+    void setProps(const HybridAixComposerProps& props) { _props.emplace(props); }
+    const std::optional<HybridAixComposerProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAixComposerState(const HybridAixComposerState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAixComposerState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAixComposerState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAixComposerProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "AixComposer" View.
+   */
+  using HybridAixComposerShadowNode = react::ConcreteViewShadowNode<HybridAixComposerComponentName /* "HybridAixComposer" */,
+                                                                    HybridAixComposerProps /* custom props */,
+                                                                    react::ViewEventEmitter /* default */,
+                                                                    HybridAixComposerState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "AixComposer" View.
+   */
+  class HybridAixComposerComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAixComposerShadowNode> {
+  public:
+    HybridAixComposerComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAixComposerProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "AixComposer" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/shared/json/AixCellViewConfig.json

@@ -0,0 +1,11 @@
+{
+  "uiViewClassName": "AixCellView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "isLast": true,
+    "index": true,
+    "hybridRef": true
+  }
+}

package/nitrogen/generated/shared/json/AixComposerConfig.json

@@ -0,0 +1,9 @@
+{
+  "uiViewClassName": "AixComposer",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "hybridRef": true
+  }
+}

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

@@ -0,0 +1,16 @@
+{
+  "uiViewClassName": "Aix",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "shouldStartAtEnd": true,
+    "scrollOnFooterSizeUpdate": true,
+    "scrollEndReachedThreshold": true,
+    "additionalContentInsets": true,
+    "additionalScrollIndicatorInsets": true,
+    "mainScrollViewID": true,
+    "penultimateCellIndex": true,
+    "hybridRef": true
+  }
+}

package/package.json

@@ -1,19 +1,122 @@
 {
   "name": "aix",
-  "version": "0.0.14",
-  "license": "MIT",
+  "version": "0.1.0-alpha.1",
+  "author": "Fernando Rojo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel/aix.git"
+  },
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
   "devDependencies": {
-    "@types/jest": "^23.1.1",
-    "@types/node": "^10.3.5",
-    "jest": "^23.1.0",
-    "ts-jest": "^22.4.6",
-    "tslint": "^5.10.0",
-    "typescript": "^2.9.2"
+    "@jamesacarr/eslint-formatter-github-actions": "^0.2.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/jest": "^29.5.12",
+    "@types/react": "19.1.1",
+    "nitrogen": "0.31.10",
+    "react": "19.1.1",
+    "react-native": "0.82",
+    "react-native-builder-bob": "^0.37.0",
+    "react-native-nitro-modules": "0.31.10",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^24.2.9",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
+  },
+  "bugs": "https://github.com/vercel/aix/issues",
+  "description": "aix is a react native package built with Nitro",
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "plugins": [
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "warn",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "files": [
+    "src",
+    "react-native.config.js",
+    "lib",
+    "nitrogen",
+    "cpp",
+    "nitro.json",
+    "android/build.gradle",
+    "android/fix-prefab.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "*.podspec",
+    "README.md"
+  ],
+  "homepage": "https://github.com/vercel/aix#readme",
+  "keywords": [
+    "react-native",
+    "aix"
+  ],
+  "license": "MIT",
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false,
+    "semi": false
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "react-native": "src/index",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.json"
+        }
+      ]
+    ]
   },
   "scripts": {
-    "test": "jest",
-    "build": "tsc"
+    "typecheck": "tsc --noEmit",
+    "clean": "git clean -dfX",
+    "release": "semantic-release",
+    "build": "bun run typecheck && bob build",
+    "codegen": "nitrogen --logLevel=\"debug\" && bun run build && node post-script.js"
   },
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts"
+  "source": "src/index",
+  "types": "./lib/typescript/src/index.d.ts"
 }

package/src/aix.tsx

@@ -0,0 +1,43 @@
+import {
+  callback,
+  getHostComponent,
+  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'
+
+export type AixRef = HybridRef<AixProps, AixMethods>
+
+const AixInternal = getHostComponent<AixProps, AixMethods>(
+  'Aix',
+  () => AixConfig
+)
+
+export const Aix = forwardRef<AixRef, React.ComponentProps<typeof AixInternal>>(
+  function Aix(props, ref) {
+    return (
+      <AixInternal
+        {...props}
+        scrollOnFooterSizeUpdate={
+          props.scrollOnFooterSizeUpdate ?? {
+            enabled: true,
+            scrolledToEndThreshold: 100,
+            animated: false,
+          }
+        }
+        hybridRef={
+          ref
+            ? callback((r) => {
+                if (typeof ref === 'function') {
+                  ref(r)
+                } else {
+                  ref.current = r
+                }
+              })
+            : undefined
+        }
+      />
+    )
+  }
+)

package/src/fade-in/createUsePool.ts

@@ -0,0 +1,46 @@
+import { useState, useRef, useEffect, useCallback } from 'react'
+
+export function createUsePool(maxPoolSize?: number) {
+  // Use parallel arrays instead of one array for fast array operations
+  const items: object[] = []
+  const setters: ((value: boolean) => void)[] = []
+
+  const removeItem = (item: object, setInactive?: boolean) => {
+    const index = items.indexOf(item)
+    if (index !== -1) {
+      if (setInactive) {
+        setters[index]!(false)
+      }
+      items.splice(index, 1)
+      setters.splice(index, 1)
+    }
+  }
+
+  const usePool = () => {
+    // Use a stable object reference as the key
+    const item = useRef({}).current
+    const [isActive, setIsActive] = useState(true)
+
+    // A function that is stable and only changes when the item changes
+    const evict = useCallback(() => removeItem(item, true), [item])
+
+    useEffect(() => {
+      items.push(item)
+      setters.push(setIsActive)
+
+      // Evict oldest item if over capacity
+      if (maxPoolSize && items.length > maxPoolSize) {
+        items.shift()
+        const evictedListener = setters.shift()!
+        evictedListener(false)
+      }
+
+      // Remove from pool when unmounting
+      return () => removeItem(item)
+    }, [item])
+
+    return { isActive, evict }
+  }
+
+  return usePool
+}

package/src/fade-in/createUseStaggered.ts

@@ -0,0 +1,82 @@
+import { useEffect, useRef } from 'react'
+
+// Creates a staggered animation system - only one animation starts per frame/delay
+export function createUseStaggered(delay: number) {
+  const animationQueue: (() => void)[] = []
+  let isProcessing = false
+
+  // Schedule next animation with delay or requestAnimationFrame
+  const scheduleNext = () => {
+    if (delay && delay > 0) {
+      setTimeout(processNextAnimation, delay)
+    } else {
+      requestAnimationFrame(processNextAnimation)
+    }
+  }
+
+  const processNextAnimation = () => {
+    if (animationQueue.length === 0) {
+      isProcessing = false
+      return
+    }
+
+    // Calculate how many animations to process this cycle
+    const queueLength = animationQueue.length
+    let animationsToProcess = 1
+
+    // Catch-up logic: process more animations when queue is long
+    if (queueLength > 10) {
+      animationsToProcess = Math.min(5, Math.ceil(queueLength / 4))
+    } else if (queueLength > 5) {
+      animationsToProcess = 2
+    }
+
+    // Process the calculated number of animations
+    for (let i = 0; i < animationsToProcess && animationQueue.length > 0; i++) {
+      const startAnimation = animationQueue.shift()!
+      startAnimation()
+    }
+
+    // Continue processing or mark as idle
+    if (animationQueue.length > 0) {
+      scheduleNext()
+    } else {
+      isProcessing = false
+    }
+  }
+
+  const queueAnimation = (startFn: () => void) => {
+    animationQueue.push(startFn)
+
+    if (!isProcessing) {
+      isProcessing = true
+      scheduleNext()
+    }
+  }
+
+  const useStaggered = (animationFn: () => void) => {
+    const animationRef = useRef<(() => void) | null>(animationFn)
+
+    // Queue animation on mount
+    useEffect(() => {
+      if (animationRef.current) {
+        queueAnimation(animationRef.current)
+      }
+    }, [])
+
+    useEffect(() => {
+      const animation = animationRef.current
+      return () => {
+        // Clean up pending animation on unmount
+        if (animation) {
+          const index = animationQueue.indexOf(animation)
+          if (index !== -1) {
+            animationQueue.splice(index, 1)
+          }
+        }
+      }
+    }, [])
+  }
+
+  return useStaggered
+}