aix 0.6.0 → 0.6.1

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

@@ -0,0 +1,87 @@
+///
+/// HybridAixDropzoneComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixDropzoneComponent.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 HybridAixDropzoneComponentName[] = "AixDropzone";
+
+  HybridAixDropzoneProps::HybridAixDropzoneProps(const react::PropsParserContext& context,
+                                                 const HybridAixDropzoneProps& sourceProps,
+                                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    onDrop([&]() -> CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onDrop", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onDrop;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onDrop);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixDropzone.onDrop: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixDropzoneSpec>& /* 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<HybridAixDropzoneSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixDropzone.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAixDropzoneProps::HybridAixDropzoneProps(const HybridAixDropzoneProps& other):
+    react::ViewProps(),
+    onDrop(other.onDrop),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAixDropzoneProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("onDrop"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAixDropzoneComponentDescriptor::HybridAixDropzoneComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAixDropzoneComponentDescriptor::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 HybridAixDropzoneShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAixDropzoneComponentDescriptor::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<HybridAixDropzoneShadowNode&>(shadowNode);
+    const HybridAixDropzoneProps& props = concreteShadowNode.getConcreteProps();
+    HybridAixDropzoneState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,109 @@
+///
+/// HybridAixDropzoneComponent.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 "AixInputWrapperOnPasteEvent.hpp"
+#include <vector>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridAixDropzoneSpec.hpp"
+
+namespace margelo::nitro::aix::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAixDropzoneComponentName[];
+
+  /**
+   * Props for the "AixDropzone" View.
+   */
+  class HybridAixDropzoneProps final: public react::ViewProps {
+  public:
+    HybridAixDropzoneProps() = default;
+    HybridAixDropzoneProps(const HybridAixDropzoneProps&);
+    HybridAixDropzoneProps(const react::PropsParserContext& context,
+                           const HybridAixDropzoneProps& sourceProps,
+                           const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>> onDrop;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixDropzoneSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "AixDropzone" View.
+   */
+  class HybridAixDropzoneState final {
+  public:
+    HybridAixDropzoneState() = default;
+
+  public:
+    void setProps(const HybridAixDropzoneProps& props) { _props.emplace(props); }
+    const std::optional<HybridAixDropzoneProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAixDropzoneState(const HybridAixDropzoneState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAixDropzoneState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAixDropzoneState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAixDropzoneProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "AixDropzone" View.
+   */
+  using HybridAixDropzoneShadowNode = react::ConcreteViewShadowNode<HybridAixDropzoneComponentName /* "HybridAixDropzone" */,
+                                                                    HybridAixDropzoneProps /* custom props */,
+                                                                    react::ViewEventEmitter /* default */,
+                                                                    HybridAixDropzoneState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "AixDropzone" View.
+   */
+  class HybridAixDropzoneComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAixDropzoneShadowNode> {
+  public:
+    HybridAixDropzoneComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAixDropzoneProps`.
+     */
+    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 "AixDropzone" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,135 @@
+///
+/// HybridAixInputWrapperComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixInputWrapperComponent.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 HybridAixInputWrapperComponentName[] = "AixInputWrapper";
+
+  HybridAixInputWrapperProps::HybridAixInputWrapperProps(const react::PropsParserContext& context,
+                                                         const HybridAixInputWrapperProps& sourceProps,
+                                                         const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    pasteConfiguration([&]() -> CachedProp<std::optional<std::vector<std::string>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("pasteConfiguration", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.pasteConfiguration;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::vector<std::string>>>::fromRawValue(*runtime, value, sourceProps.pasteConfiguration);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.pasteConfiguration: ") + exc.what());
+      }
+    }()),
+    editMenuDefaultActions([&]() -> CachedProp<std::optional<std::vector<std::string>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("editMenuDefaultActions", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.editMenuDefaultActions;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::vector<std::string>>>::fromRawValue(*runtime, value, sourceProps.editMenuDefaultActions);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.editMenuDefaultActions: ") + exc.what());
+      }
+    }()),
+    maxLines([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxLines", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxLines;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxLines);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.maxLines: ") + exc.what());
+      }
+    }()),
+    maxChars([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxChars", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxChars;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxChars);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.maxChars: ") + exc.what());
+      }
+    }()),
+    onPaste([&]() -> CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onPaste", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onPaste;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onPaste);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.onPaste: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixInputWrapperSpec>& /* 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<HybridAixInputWrapperSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixInputWrapper.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAixInputWrapperProps::HybridAixInputWrapperProps(const HybridAixInputWrapperProps& other):
+    react::ViewProps(),
+    pasteConfiguration(other.pasteConfiguration),
+    editMenuDefaultActions(other.editMenuDefaultActions),
+    maxLines(other.maxLines),
+    maxChars(other.maxChars),
+    onPaste(other.onPaste),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAixInputWrapperProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("pasteConfiguration"): return true;
+      case hashString("editMenuDefaultActions"): return true;
+      case hashString("maxLines"): return true;
+      case hashString("maxChars"): return true;
+      case hashString("onPaste"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAixInputWrapperComponentDescriptor::HybridAixInputWrapperComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAixInputWrapperComponentDescriptor::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 HybridAixInputWrapperShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAixInputWrapperComponentDescriptor::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<HybridAixInputWrapperShadowNode&>(shadowNode);
+    const HybridAixInputWrapperProps& props = concreteShadowNode.getConcreteProps();
+    HybridAixInputWrapperState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,114 @@
+///
+/// HybridAixInputWrapperComponent.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 <string>
+#include <vector>
+#include <optional>
+#include "AixInputWrapperOnPasteEvent.hpp"
+#include <functional>
+#include <memory>
+#include "HybridAixInputWrapperSpec.hpp"
+
+namespace margelo::nitro::aix::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAixInputWrapperComponentName[];
+
+  /**
+   * Props for the "AixInputWrapper" View.
+   */
+  class HybridAixInputWrapperProps final: public react::ViewProps {
+  public:
+    HybridAixInputWrapperProps() = default;
+    HybridAixInputWrapperProps(const HybridAixInputWrapperProps&);
+    HybridAixInputWrapperProps(const react::PropsParserContext& context,
+                               const HybridAixInputWrapperProps& sourceProps,
+                               const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::vector<std::string>>> pasteConfiguration;
+    CachedProp<std::optional<std::vector<std::string>>> editMenuDefaultActions;
+    CachedProp<std::optional<double>> maxLines;
+    CachedProp<std::optional<double>> maxChars;
+    CachedProp<std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>> onPaste;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixInputWrapperSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "AixInputWrapper" View.
+   */
+  class HybridAixInputWrapperState final {
+  public:
+    HybridAixInputWrapperState() = default;
+
+  public:
+    void setProps(const HybridAixInputWrapperProps& props) { _props.emplace(props); }
+    const std::optional<HybridAixInputWrapperProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAixInputWrapperState(const HybridAixInputWrapperState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAixInputWrapperState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAixInputWrapperState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAixInputWrapperProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "AixInputWrapper" View.
+   */
+  using HybridAixInputWrapperShadowNode = react::ConcreteViewShadowNode<HybridAixInputWrapperComponentName /* "HybridAixInputWrapper" */,
+                                                                        HybridAixInputWrapperProps /* custom props */,
+                                                                        react::ViewEventEmitter /* default */,
+                                                                        HybridAixInputWrapperState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "AixInputWrapper" View.
+   */
+  class HybridAixInputWrapperComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAixInputWrapperShadowNode> {
+  public:
+    HybridAixInputWrapperComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAixInputWrapperProps`.
+     */
+    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 "AixInputWrapper" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::aix::views

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

@@ -5,6 +5,7 @@
   "directEventTypes": {},
   "validAttributes": {
     "stickToKeyboard": true,
+    "fixInput": true,
     "hybridRef": true
   }
 }

package/nitrogen/generated/shared/json/AixDropzoneConfig.json

@@ -0,0 +1,10 @@
+{
+  "uiViewClassName": "AixDropzone",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "onDrop": true,
+    "hybridRef": true
+  }
+}

package/nitrogen/generated/shared/json/AixInputWrapperConfig.json

@@ -0,0 +1,14 @@
+{
+  "uiViewClassName": "AixInputWrapper",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "pasteConfiguration": true,
+    "editMenuDefaultActions": true,
+    "maxLines": true,
+    "maxChars": true,
+    "onPaste": true,
+    "hybridRef": true
+  }
+}

package/package.json

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

package/src/dropzone.ios.tsx

@@ -0,0 +1,27 @@
+import { callback, getHostComponent } from 'react-native-nitro-modules'
+import AixDropzoneConfig from '../nitrogen/generated/shared/json/AixDropzoneConfig.json'
+import type { AixDropzoneProps, AixInputWrapperOnPasteEvent } from './views/aix.nitro'
+import type { ComponentProps } from 'react'
+
+const AixDropzoneInternal = getHostComponent<AixDropzoneProps, {}>(
+  'AixDropzone',
+  () => AixDropzoneConfig,
+)
+
+type AixDropzoneComponentProps = Omit<
+  ComponentProps<typeof AixDropzoneInternal>,
+  'onDrop' | 'hybridRef'
+> & {
+  onDrop?: (events: AixInputWrapperOnPasteEvent[]) => void
+}
+
+export function AixDropzone(props: AixDropzoneComponentProps) {
+  return (
+    <AixDropzoneInternal
+      {...props}
+      onDrop={props.onDrop ? callback(props.onDrop) : undefined}
+    >
+      {props.children}
+    </AixDropzoneInternal>
+  )
+}

package/src/dropzone.tsx

@@ -0,0 +1,10 @@
+import type { PropsWithChildren } from 'react'
+import type { AixInputWrapperOnPasteEvent } from './views/aix.nitro'
+
+export type AixDropzoneComponentProps = PropsWithChildren<{
+  onDrop?: (events: AixInputWrapperOnPasteEvent[]) => void
+}>
+
+export function AixDropzone(props: AixDropzoneComponentProps) {
+  return <>{props.children}</>
+}

package/src/index.ts

@@ -7,6 +7,9 @@ export * from './fade-in'
 
 export { Aix, type AixRef } from './aix'
 export { AixFooter } from './footer'
+export { AixInputWrapper } from './input-wrapper'
+export { AixDropzone } from './dropzone'
+export type { AixInputWrapperOnPasteEvent } from './views/aix.nitro'
 export { useContentInsetHandler } from './hooks/useContentInsetHandler'
 export type { AixContentInsets } from './views/aix.nitro'
 

package/src/input-wrapper.ios.tsx

@@ -0,0 +1,30 @@
+import { callback, getHostComponent } from 'react-native-nitro-modules'
+import AixInputWrapperConfig from '../nitrogen/generated/shared/json/AixInputWrapperConfig.json'
+import type {
+  AixInputWrapperProps,
+  AixInputWrapperOnPasteEvent,
+} from './views/aix.nitro'
+import type { ComponentProps } from 'react'
+
+const AixInputWrapperInternal = getHostComponent<AixInputWrapperProps, {}>(
+  'AixInputWrapper',
+  () => AixInputWrapperConfig
+)
+
+type AixInputWrapperComponentProps = Omit<
+  ComponentProps<typeof AixInputWrapperInternal>,
+  'onPaste' | 'hybridRef'
+> & {
+  onPaste?: (events: AixInputWrapperOnPasteEvent[]) => void
+}
+
+export function AixInputWrapper(props: AixInputWrapperComponentProps) {
+  return (
+    <AixInputWrapperInternal
+      {...props}
+      onPaste={props.onPaste ? callback(props.onPaste) : undefined}
+    >
+      {props.children}
+    </AixInputWrapperInternal>
+  )
+}

package/src/input-wrapper.tsx

@@ -0,0 +1,17 @@
+import type { PropsWithChildren } from 'react'
+import type { ViewProps } from 'react-native'
+import type {
+  AixInputWrapperOnPasteEvent,
+  AixInputWrapperProps,
+} from './views/aix.nitro'
+
+type AixInputWrapperComponentProps = PropsWithChildren<
+  ViewProps &
+    Omit<AixInputWrapperProps, 'onPaste'> & {
+      onPaste?: (events: AixInputWrapperOnPasteEvent[]) => void
+    }
+>
+
+export function AixInputWrapper(props: AixInputWrapperComponentProps) {
+  return <>{props.children}</>
+}