react-native-nitro-ar 2026.2.1

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

@@ -0,0 +1,88 @@
+///
+/// TrackingStateReason.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::ar {
+
+  /**
+   * An enum which can be represented as a JavaScript union (TrackingStateReason).
+   */
+  enum class TrackingStateReason {
+    NONE      SWIFT_NAME(none) = 0,
+    INITIALIZING      SWIFT_NAME(initializing) = 1,
+    EXCESSIVEMOTION      SWIFT_NAME(excessivemotion) = 2,
+    INSUFFICIENTFEATURES      SWIFT_NAME(insufficientfeatures) = 3,
+    RELOCALIZING      SWIFT_NAME(relocalizing) = 4,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ TrackingStateReason <> JS TrackingStateReason (union)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::TrackingStateReason> final {
+    static inline margelo::nitro::ar::TrackingStateReason fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::ar::TrackingStateReason::NONE;
+        case hashString("initializing"): return margelo::nitro::ar::TrackingStateReason::INITIALIZING;
+        case hashString("excessiveMotion"): return margelo::nitro::ar::TrackingStateReason::EXCESSIVEMOTION;
+        case hashString("insufficientFeatures"): return margelo::nitro::ar::TrackingStateReason::INSUFFICIENTFEATURES;
+        case hashString("relocalizing"): return margelo::nitro::ar::TrackingStateReason::RELOCALIZING;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TrackingStateReason - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ar::TrackingStateReason arg) {
+      switch (arg) {
+        case margelo::nitro::ar::TrackingStateReason::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::ar::TrackingStateReason::INITIALIZING: return JSIConverter<std::string>::toJSI(runtime, "initializing");
+        case margelo::nitro::ar::TrackingStateReason::EXCESSIVEMOTION: return JSIConverter<std::string>::toJSI(runtime, "excessiveMotion");
+        case margelo::nitro::ar::TrackingStateReason::INSUFFICIENTFEATURES: return JSIConverter<std::string>::toJSI(runtime, "insufficientFeatures");
+        case margelo::nitro::ar::TrackingStateReason::RELOCALIZING: return JSIConverter<std::string>::toJSI(runtime, "relocalizing");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert TrackingStateReason to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("initializing"):
+        case hashString("excessiveMotion"):
+        case hashString("insufficientFeatures"):
+        case hashString("relocalizing"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// WorldAlignment.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::ar {
+
+  /**
+   * An enum which can be represented as a JavaScript union (WorldAlignment).
+   */
+  enum class WorldAlignment {
+    GRAVITY      SWIFT_NAME(gravity) = 0,
+    GRAVITYANDHEADING      SWIFT_NAME(gravityandheading) = 1,
+    CAMERA      SWIFT_NAME(camera) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ WorldAlignment <> JS WorldAlignment (union)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::WorldAlignment> final {
+    static inline margelo::nitro::ar::WorldAlignment fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("gravity"): return margelo::nitro::ar::WorldAlignment::GRAVITY;
+        case hashString("gravityAndHeading"): return margelo::nitro::ar::WorldAlignment::GRAVITYANDHEADING;
+        case hashString("camera"): return margelo::nitro::ar::WorldAlignment::CAMERA;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum WorldAlignment - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ar::WorldAlignment arg) {
+      switch (arg) {
+        case margelo::nitro::ar::WorldAlignment::GRAVITY: return JSIConverter<std::string>::toJSI(runtime, "gravity");
+        case margelo::nitro::ar::WorldAlignment::GRAVITYANDHEADING: return JSIConverter<std::string>::toJSI(runtime, "gravityAndHeading");
+        case margelo::nitro::ar::WorldAlignment::CAMERA: return JSIConverter<std::string>::toJSI(runtime, "camera");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert WorldAlignment to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("gravity"):
+        case hashString("gravityAndHeading"):
+        case hashString("camera"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,84 @@
+///
+/// WorldMappingStatus.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::ar {
+
+  /**
+   * An enum which can be represented as a JavaScript union (WorldMappingStatus).
+   */
+  enum class WorldMappingStatus {
+    NOTAVAILABLE      SWIFT_NAME(notavailable) = 0,
+    LIMITED      SWIFT_NAME(limited) = 1,
+    EXTENDING      SWIFT_NAME(extending) = 2,
+    MAPPED      SWIFT_NAME(mapped) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ WorldMappingStatus <> JS WorldMappingStatus (union)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::WorldMappingStatus> final {
+    static inline margelo::nitro::ar::WorldMappingStatus fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("notAvailable"): return margelo::nitro::ar::WorldMappingStatus::NOTAVAILABLE;
+        case hashString("limited"): return margelo::nitro::ar::WorldMappingStatus::LIMITED;
+        case hashString("extending"): return margelo::nitro::ar::WorldMappingStatus::EXTENDING;
+        case hashString("mapped"): return margelo::nitro::ar::WorldMappingStatus::MAPPED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum WorldMappingStatus - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ar::WorldMappingStatus arg) {
+      switch (arg) {
+        case margelo::nitro::ar::WorldMappingStatus::NOTAVAILABLE: return JSIConverter<std::string>::toJSI(runtime, "notAvailable");
+        case margelo::nitro::ar::WorldMappingStatus::LIMITED: return JSIConverter<std::string>::toJSI(runtime, "limited");
+        case margelo::nitro::ar::WorldMappingStatus::EXTENDING: return JSIConverter<std::string>::toJSI(runtime, "extending");
+        case margelo::nitro::ar::WorldMappingStatus::MAPPED: return JSIConverter<std::string>::toJSI(runtime, "mapped");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert WorldMappingStatus to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("notAvailable"):
+        case hashString("limited"):
+        case hashString("extending"):
+        case hashString("mapped"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,182 @@
+///
+/// HybridARViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARViewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.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::ar::views {
+
+  extern const char HybridARViewComponentName[] = "ARView";
+
+  HybridARViewProps::HybridARViewProps(const react::PropsParserContext& context,
+                                       const HybridARViewProps& sourceProps,
+                                       const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    showDebugOptions([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showDebugOptions", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showDebugOptions;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showDebugOptions);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.showDebugOptions: ") + exc.what());
+      }
+    }()),
+    showPlanes([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showPlanes", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showPlanes;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showPlanes);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.showPlanes: ") + exc.what());
+      }
+    }()),
+    showFeaturePoints([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showFeaturePoints", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showFeaturePoints;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showFeaturePoints);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.showFeaturePoints: ") + exc.what());
+      }
+    }()),
+    showWorldOrigin([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showWorldOrigin", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showWorldOrigin;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showWorldOrigin);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.showWorldOrigin: ") + exc.what());
+      }
+    }()),
+    autoenablesDefaultLighting([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("autoenablesDefaultLighting", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.autoenablesDefaultLighting;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.autoenablesDefaultLighting);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.autoenablesDefaultLighting: ") + exc.what());
+      }
+    }()),
+    sceneReconstruction([&]() -> CachedProp<std::optional<SceneReconstructionMode>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sceneReconstruction", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sceneReconstruction;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<SceneReconstructionMode>>::fromRawValue(*runtime, value, sourceProps.sceneReconstruction);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.sceneReconstruction: ") + exc.what());
+      }
+    }()),
+    showSceneMesh([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showSceneMesh", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showSceneMesh;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showSceneMesh);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.showSceneMesh: ") + exc.what());
+      }
+    }()),
+    sceneDepth([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sceneDepth", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sceneDepth;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.sceneDepth);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.sceneDepth: ") + exc.what());
+      }
+    }()),
+    objectOcclusion([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("objectOcclusion", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.objectOcclusion;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.objectOcclusion);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.objectOcclusion: ") + exc.what());
+      }
+    }()),
+    peopleOcclusion([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("peopleOcclusion", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.peopleOcclusion;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.peopleOcclusion);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.peopleOcclusion: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridARViewSpec>& /* 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<HybridARViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ARView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridARViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("showDebugOptions"): return true;
+      case hashString("showPlanes"): return true;
+      case hashString("showFeaturePoints"): return true;
+      case hashString("showWorldOrigin"): return true;
+      case hashString("autoenablesDefaultLighting"): return true;
+      case hashString("sceneReconstruction"): return true;
+      case hashString("showSceneMesh"): return true;
+      case hashString("sceneDepth"): return true;
+      case hashString("objectOcclusion"): return true;
+      case hashString("peopleOcclusion"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridARViewComponentDescriptor::HybridARViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridARViewComponentDescriptor::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 HybridARViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridARViewComponentDescriptor::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 = static_cast<HybridARViewShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridARViewProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridARViewProps>& props = std::const_pointer_cast<HybridARViewProps>(constProps);
+    HybridARViewState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::ar::views

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

@@ -0,0 +1,120 @@
+///
+/// HybridARViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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 <optional>
+#include "SceneReconstructionMode.hpp"
+#include <memory>
+#include "HybridARViewSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::ar::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridARViewComponentName[];
+
+  /**
+   * Props for the "ARView" View.
+   */
+  class HybridARViewProps final: public react::ViewProps {
+  public:
+    HybridARViewProps() = default;
+    HybridARViewProps(const react::PropsParserContext& context,
+                      const HybridARViewProps& sourceProps,
+                      const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<bool>> showDebugOptions;
+    CachedProp<std::optional<bool>> showPlanes;
+    CachedProp<std::optional<bool>> showFeaturePoints;
+    CachedProp<std::optional<bool>> showWorldOrigin;
+    CachedProp<std::optional<bool>> autoenablesDefaultLighting;
+    CachedProp<std::optional<SceneReconstructionMode>> sceneReconstruction;
+    CachedProp<std::optional<bool>> showSceneMesh;
+    CachedProp<std::optional<bool>> sceneDepth;
+    CachedProp<std::optional<bool>> objectOcclusion;
+    CachedProp<std::optional<bool>> peopleOcclusion;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridARViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "ARView" View.
+   */
+  class HybridARViewState final {
+  public:
+    HybridARViewState() = default;
+    explicit HybridARViewState(const std::shared_ptr<HybridARViewProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridARViewProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridARViewState(const HybridARViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridARViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridARViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridARViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "ARView" View.
+   */
+  using HybridARViewShadowNode = react::ConcreteViewShadowNode<HybridARViewComponentName /* "HybridARView" */,
+                                                               HybridARViewProps /* custom props */,
+                                                               react::ViewEventEmitter /* default */,
+                                                               HybridARViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "ARView" View.
+   */
+  class HybridARViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridARViewShadowNode> {
+  public:
+    explicit HybridARViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridARViewProps`.
+     */
+    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 "ARView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::ar::views

package/nitrogen/generated/shared/json/ARViewConfig.json

@@ -0,0 +1,19 @@
+{
+  "uiViewClassName": "ARView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "showDebugOptions": true,
+    "showPlanes": true,
+    "showFeaturePoints": true,
+    "showWorldOrigin": true,
+    "autoenablesDefaultLighting": true,
+    "sceneReconstruction": true,
+    "showSceneMesh": true,
+    "sceneDepth": true,
+    "objectOcclusion": true,
+    "peopleOcclusion": true,
+    "hybridRef": true
+  }
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "react-native-nitro-ar",
+  "description": "Nitro module for ARKit (iOS)",
+  "version": "2026.02.1",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "expo": {
+    "pluginFile": "app.plugin.js"
+  },
+  "scripts": {
+    "format": "bunx biome check --write --no-errors-on-unmatched .",
+    "typecheck": "tsc --noEmit",
+    "clean": "git clean -dfX",
+    "release": "semantic-release",
+    "build": "bun run typecheck && bob build",
+    "codegen": "nitrogen --logLevel=\"debug\" && bun run build"
+  },
+  "keywords": [
+    "react-native",
+    "react-native-nitro-ar",
+    "nitro",
+    "ar",
+    "arkit"
+  ],
+  "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"
+  ],
+  "workspaces": [
+    "example"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vineyardbovines/react-native-nitro-ar.git"
+  },
+  "author": "Spencer Pope <spencer@thepope.dev>",
+  "license": "MIT",
+  "bugs": "https://github.com/vineyardbovines/react-native-nitro-ar/issues",
+  "homepage": "https://github.com/vineyardbovines/react-native-nitro-ar#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@vineyardbovines/calver": "^2026.1.1",
+    "commitlint": "^20.4.1",
+    "lefthook": "^2.0.16",
+    "nitrogen": "^0.33.7",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.2.4",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "bun@1.2.22",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.json"
+        }
+      ]
+    ]
+  }
+}