@abeman/react-native-nitro-blur 0.1.0

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

@@ -0,0 +1,75 @@
+///
+/// HybridNitroBlurSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `BlurTint` to properly resolve imports.
+namespace margelo::nitro::nitroblur { enum class BlurTint; }
+// Forward declaration of `BlurMethod` to properly resolve imports.
+namespace margelo::nitro::nitroblur { enum class BlurMethod; }
+
+#include "BlurTint.hpp"
+#include "BlurMethod.hpp"
+
+namespace margelo::nitro::nitroblur {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NitroBlur`
+   * Inherit this class to create instances of `HybridNitroBlurSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNitroBlur: public HybridNitroBlurSpec {
+   * public:
+   *   HybridNitroBlur(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNitroBlurSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNitroBlurSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNitroBlurSpec() override = default;
+
+    public:
+      // Properties
+      virtual BlurTint getTint() = 0;
+      virtual void setTint(BlurTint tint) = 0;
+      virtual double getIntensity() = 0;
+      virtual void setIntensity(double intensity) = 0;
+      virtual double getBlurReductionFactor() = 0;
+      virtual void setBlurReductionFactor(double blurReductionFactor) = 0;
+      virtual double getBlurTargetId() = 0;
+      virtual void setBlurTargetId(double blurTargetId) = 0;
+      virtual BlurMethod getBlurMethod() = 0;
+      virtual void setBlurMethod(BlurMethod blurMethod) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NitroBlur";
+  };
+
+} // namespace margelo::nitro::nitroblur

package/nitrogen/generated/shared/c++/HybridNitroBlurTargetSpec.cpp

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

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

@@ -0,0 +1,62 @@
+///
+/// HybridNitroBlurTargetSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::nitroblur {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NitroBlurTarget`
+   * Inherit this class to create instances of `HybridNitroBlurTargetSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNitroBlurTarget: public HybridNitroBlurTargetSpec {
+   * public:
+   *   HybridNitroBlurTarget(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNitroBlurTargetSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNitroBlurTargetSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNitroBlurTargetSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NitroBlurTarget";
+  };
+
+} // namespace margelo::nitro::nitroblur

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

@@ -0,0 +1,127 @@
+///
+/// HybridNitroBlurComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBlurComponent.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::nitroblur::views {
+
+  extern const char HybridNitroBlurComponentName[] = "NitroBlur";
+
+  HybridNitroBlurProps::HybridNitroBlurProps(const react::PropsParserContext& context,
+                                             const HybridNitroBlurProps& sourceProps,
+                                             const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    tint([&]() -> CachedProp<BlurTint> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("tint", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.tint;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<BlurTint>::fromRawValue(*runtime, value, sourceProps.tint);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroBlur.tint: ") + exc.what());
+      }
+    }()),
+    intensity([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("intensity", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.intensity;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.intensity);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroBlur.intensity: ") + exc.what());
+      }
+    }()),
+    blurReductionFactor([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("blurReductionFactor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.blurReductionFactor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.blurReductionFactor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroBlur.blurReductionFactor: ") + exc.what());
+      }
+    }()),
+    blurTargetId([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("blurTargetId", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.blurTargetId;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.blurTargetId);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroBlur.blurTargetId: ") + exc.what());
+      }
+    }()),
+    blurMethod([&]() -> CachedProp<BlurMethod> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("blurMethod", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.blurMethod;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<BlurMethod>::fromRawValue(*runtime, value, sourceProps.blurMethod);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroBlur.blurMethod: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroBlurSpec>& /* 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<HybridNitroBlurSpec>& /* 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("NitroBlur.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridNitroBlurProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("tint"): return true;
+      case hashString("intensity"): return true;
+      case hashString("blurReductionFactor"): return true;
+      case hashString("blurTargetId"): return true;
+      case hashString("blurMethod"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridNitroBlurComponentDescriptor::HybridNitroBlurComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridNitroBlurComponentDescriptor::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 HybridNitroBlurShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridNitroBlurComponentDescriptor::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<HybridNitroBlurShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridNitroBlurProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridNitroBlurProps>& props = std::const_pointer_cast<HybridNitroBlurProps>(constProps);
+    HybridNitroBlurState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::nitroblur::views

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

@@ -0,0 +1,116 @@
+///
+/// HybridNitroBlurComponent.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 "BlurTint.hpp"
+#include "BlurMethod.hpp"
+#include <memory>
+#include "HybridNitroBlurSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::nitroblur::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridNitroBlurComponentName[];
+
+  /**
+   * Props for the "NitroBlur" View.
+   */
+  class HybridNitroBlurProps final: public react::ViewProps {
+  public:
+    HybridNitroBlurProps() = default;
+    HybridNitroBlurProps(const react::PropsParserContext& context,
+                         const HybridNitroBlurProps& sourceProps,
+                         const react::RawProps& rawProps);
+
+  public:
+    CachedProp<BlurTint> tint;
+    CachedProp<double> intensity;
+    CachedProp<double> blurReductionFactor;
+    CachedProp<double> blurTargetId;
+    CachedProp<BlurMethod> blurMethod;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroBlurSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "NitroBlur" View.
+   */
+  class HybridNitroBlurState final {
+  public:
+    HybridNitroBlurState() = default;
+    explicit HybridNitroBlurState(const std::shared_ptr<HybridNitroBlurProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridNitroBlurProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridNitroBlurState(const HybridNitroBlurState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridNitroBlurState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridNitroBlurState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridNitroBlurProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "NitroBlur" View.
+   */
+  using HybridNitroBlurShadowNode = react::ConcreteViewShadowNode<HybridNitroBlurComponentName /* "HybridNitroBlur" */,
+                                                                  HybridNitroBlurProps /* custom props */,
+                                                                  react::ViewEventEmitter /* default */,
+                                                                  HybridNitroBlurState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "NitroBlur" View.
+   */
+  class HybridNitroBlurComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridNitroBlurShadowNode> {
+  public:
+    explicit HybridNitroBlurComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridNitroBlurProps`.
+     */
+    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 "NitroBlur" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::nitroblur::views

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

@@ -0,0 +1,72 @@
+///
+/// HybridNitroBlurTargetComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBlurTargetComponent.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::nitroblur::views {
+
+  extern const char HybridNitroBlurTargetComponentName[] = "NitroBlurTarget";
+
+  HybridNitroBlurTargetProps::HybridNitroBlurTargetProps(const react::PropsParserContext& context,
+                                                         const HybridNitroBlurTargetProps& sourceProps,
+                                                         const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroBlurTargetSpec>& /* 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<HybridNitroBlurTargetSpec>& /* 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("NitroBlurTarget.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridNitroBlurTargetProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridNitroBlurTargetComponentDescriptor::HybridNitroBlurTargetComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridNitroBlurTargetComponentDescriptor::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 HybridNitroBlurTargetShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridNitroBlurTargetComponentDescriptor::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<HybridNitroBlurTargetShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridNitroBlurTargetProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridNitroBlurTargetProps>& props = std::const_pointer_cast<HybridNitroBlurTargetProps>(constProps);
+    HybridNitroBlurTargetState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::nitroblur::views

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

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

package/nitrogen/generated/shared/json/NitroBlurConfig.json

@@ -0,0 +1,14 @@
+{
+  "uiViewClassName": "NitroBlur",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "tint": true,
+    "intensity": true,
+    "blurReductionFactor": true,
+    "blurTargetId": true,
+    "blurMethod": true,
+    "hybridRef": true
+  }
+}

package/nitrogen/generated/shared/json/NitroBlurTargetConfig.json

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