@onekeyfe/react-native-scroll-guard 0.1.1

package/lib/nitrogen/generated/ios/swift/ScrollGuardDirection.swift

@@ -0,0 +1,44 @@
+///
+/// ScrollGuardDirection.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `ScrollGuardDirection`, backed by a C++ enum.
+ */
+public typealias ScrollGuardDirection = margelo.nitro.scrollguard.ScrollGuardDirection
+
+public extension ScrollGuardDirection {
+  /**
+   * Get a ScrollGuardDirection for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "horizontal":
+        self = .horizontal
+      case "vertical":
+        self = .vertical
+      case "both":
+        self = .both
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ScrollGuardDirection represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .horizontal:
+        return "horizontal"
+      case .vertical:
+        return "vertical"
+      case .both:
+        return "both"
+    }
+  }
+}

package/lib/nitrogen/generated/shared/c++/HybridScrollGuardSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridScrollGuardSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridScrollGuardSpec.hpp"
+
+namespace margelo::nitro::scrollguard {
+
+  void HybridScrollGuardSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("direction", &HybridScrollGuardSpec::getDirection);
+      prototype.registerHybridSetter("direction", &HybridScrollGuardSpec::setDirection);
+    });
+  }
+
+} // namespace margelo::nitro::scrollguard

package/lib/nitrogen/generated/shared/c++/HybridScrollGuardSpec.hpp

@@ -0,0 +1,65 @@
+///
+/// HybridScrollGuardSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ScrollGuardDirection` to properly resolve imports.
+namespace margelo::nitro::scrollguard { enum class ScrollGuardDirection; }
+
+#include "ScrollGuardDirection.hpp"
+#include <optional>
+
+namespace margelo::nitro::scrollguard {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ScrollGuard`
+   * Inherit this class to create instances of `HybridScrollGuardSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridScrollGuard: public HybridScrollGuardSpec {
+   * public:
+   *   HybridScrollGuard(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridScrollGuardSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridScrollGuardSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridScrollGuardSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<ScrollGuardDirection> getDirection() = 0;
+      virtual void setDirection(std::optional<ScrollGuardDirection> direction) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ScrollGuard";
+  };
+
+} // namespace margelo::nitro::scrollguard

package/lib/nitrogen/generated/shared/c++/ScrollGuardDirection.hpp

@@ -0,0 +1,80 @@
+///
+/// ScrollGuardDirection.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 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::scrollguard {
+
+  /**
+   * An enum which can be represented as a JavaScript union (ScrollGuardDirection).
+   */
+  enum class ScrollGuardDirection {
+    HORIZONTAL      SWIFT_NAME(horizontal) = 0,
+    VERTICAL      SWIFT_NAME(vertical) = 1,
+    BOTH      SWIFT_NAME(both) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::scrollguard
+
+namespace margelo::nitro {
+
+  // C++ ScrollGuardDirection <> JS ScrollGuardDirection (union)
+  template <>
+  struct JSIConverter<margelo::nitro::scrollguard::ScrollGuardDirection> final {
+    static inline margelo::nitro::scrollguard::ScrollGuardDirection 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("horizontal"): return margelo::nitro::scrollguard::ScrollGuardDirection::HORIZONTAL;
+        case hashString("vertical"): return margelo::nitro::scrollguard::ScrollGuardDirection::VERTICAL;
+        case hashString("both"): return margelo::nitro::scrollguard::ScrollGuardDirection::BOTH;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum ScrollGuardDirection - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::scrollguard::ScrollGuardDirection arg) {
+      switch (arg) {
+        case margelo::nitro::scrollguard::ScrollGuardDirection::HORIZONTAL: return JSIConverter<std::string>::toJSI(runtime, "horizontal");
+        case margelo::nitro::scrollguard::ScrollGuardDirection::VERTICAL: return JSIConverter<std::string>::toJSI(runtime, "vertical");
+        case margelo::nitro::scrollguard::ScrollGuardDirection::BOTH: return JSIConverter<std::string>::toJSI(runtime, "both");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert ScrollGuardDirection 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("horizontal"):
+        case hashString("vertical"):
+        case hashString("both"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/lib/nitrogen/generated/shared/c++/views/HybridScrollGuardComponent.cpp

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

package/lib/nitrogen/generated/shared/c++/views/HybridScrollGuardComponent.hpp

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

package/lib/nitrogen/generated/shared/json/ScrollGuardConfig.json

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

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/ScrollGuard.nitro.d.ts

@@ -0,0 +1,19 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export declare enum ScrollGuardDirection {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical",
+    BOTH = "both"
+}
+export interface ScrollGuardProps extends HybridViewProps {
+    /**
+     * The scroll direction to guard.
+     * - HORIZONTAL: block parent from intercepting horizontal gestures (default)
+     * - VERTICAL: block parent from intercepting vertical gestures
+     * - BOTH: block both directions
+     */
+    direction?: ScrollGuardDirection;
+}
+export interface ScrollGuardMethods extends HybridViewMethods {
+}
+export type ScrollGuard = HybridView<ScrollGuardProps, ScrollGuardMethods>;
+//# sourceMappingURL=ScrollGuard.nitro.d.ts.map

package/lib/typescript/src/ScrollGuard.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollGuard.nitro.d.ts","sourceRoot":"","sources":["../../../src/ScrollGuard.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,oBAAY,oBAAoB;IAC9B,UAAU,eAAe;IACzB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,oBAAoB,CAAC;CAClC;AAED,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;CAAG;AAEhE,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,5 @@
+import type { ScrollGuardMethods, ScrollGuardProps } from './ScrollGuard.nitro';
+export { ScrollGuardDirection } from './ScrollGuard.nitro';
+export declare const ScrollGuardView: import("react-native-nitro-modules").ReactNativeView<ScrollGuardProps, ScrollGuardMethods>;
+export type { ScrollGuardProps, ScrollGuardMethods };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,eAAO,MAAM,eAAe,4FAGa,CAAC;AAE1C,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["scrollguard"],
+  "ios": {
+    "iosModuleName": "ScrollGuard"
+  },
+  "android": {
+    "androidNamespace": ["scrollguard"],
+    "androidCxxLibName": "scrollguard"
+  },
+  "autolinking": {
+    "ScrollGuard": {
+      "swift": "HybridScrollGuard",
+      "kotlin": "HybridScrollGuard"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JHybridScrollGuardSpec.cpp

@@ -0,0 +1,59 @@
+///
+/// JHybridScrollGuardSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridScrollGuardSpec.hpp"
+
+// Forward declaration of `ScrollGuardDirection` to properly resolve imports.
+namespace margelo::nitro::scrollguard { enum class ScrollGuardDirection; }
+
+#include "ScrollGuardDirection.hpp"
+#include <optional>
+#include "JScrollGuardDirection.hpp"
+
+namespace margelo::nitro::scrollguard {
+
+  jni::local_ref<JHybridScrollGuardSpec::jhybriddata> JHybridScrollGuardSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridScrollGuardSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridScrollGuardSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridScrollGuardSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridScrollGuardSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridScrollGuardSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<ScrollGuardDirection> JHybridScrollGuardSpec::getDirection() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JScrollGuardDirection>()>("getDirection");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridScrollGuardSpec::setDirection(std::optional<ScrollGuardDirection> direction) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScrollGuardDirection> /* direction */)>("setDirection");
+    method(_javaPart, direction.has_value() ? JScrollGuardDirection::fromCpp(direction.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::scrollguard

package/nitrogen/generated/android/c++/JHybridScrollGuardSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridScrollGuardSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridScrollGuardSpec.hpp"
+
+
+
+
+namespace margelo::nitro::scrollguard {
+
+  using namespace facebook;
+
+  class JHybridScrollGuardSpec: public jni::HybridClass<JHybridScrollGuardSpec, JHybridObject>,
+                                public virtual HybridScrollGuardSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/scrollguard/HybridScrollGuardSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridScrollGuardSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridScrollGuardSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridScrollGuardSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridScrollGuardSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<ScrollGuardDirection> getDirection() override;
+    void setDirection(std::optional<ScrollGuardDirection> direction) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridScrollGuardSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::scrollguard

package/nitrogen/generated/android/c++/JScrollGuardDirection.hpp

@@ -0,0 +1,62 @@
+///
+/// JScrollGuardDirection.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 <fbjni/fbjni.h>
+#include "ScrollGuardDirection.hpp"
+
+namespace margelo::nitro::scrollguard {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ScrollGuardDirection" and the the Kotlin enum "ScrollGuardDirection".
+   */
+  struct JScrollGuardDirection final: public jni::JavaClass<JScrollGuardDirection> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/scrollguard/ScrollGuardDirection;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ScrollGuardDirection.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ScrollGuardDirection toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ScrollGuardDirection>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JScrollGuardDirection> fromCpp(ScrollGuardDirection value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldHORIZONTAL = clazz->getStaticField<JScrollGuardDirection>("HORIZONTAL");
+      static const auto fieldVERTICAL = clazz->getStaticField<JScrollGuardDirection>("VERTICAL");
+      static const auto fieldBOTH = clazz->getStaticField<JScrollGuardDirection>("BOTH");
+      
+      switch (value) {
+        case ScrollGuardDirection::HORIZONTAL:
+          return clazz->getStaticFieldValue(fieldHORIZONTAL);
+        case ScrollGuardDirection::VERTICAL:
+          return clazz->getStaticFieldValue(fieldVERTICAL);
+        case ScrollGuardDirection::BOTH:
+          return clazz->getStaticFieldValue(fieldBOTH);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::scrollguard