@onekeyfe/react-native-skeleton 1.1.11

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

@@ -0,0 +1,67 @@
+///
+/// HybridSkeletonSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::skeleton {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Skeleton`
+   * Inherit this class to create instances of `HybridSkeletonSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSkeleton: public HybridSkeletonSpec {
+   * public:
+   *   HybridSkeleton(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSkeletonSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSkeletonSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSkeletonSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<double> getShimmerSpeed() = 0;
+      virtual void setShimmerSpeed(std::optional<double> shimmerSpeed) = 0;
+      virtual std::optional<std::vector<std::string>> getShimmerGradientColors() = 0;
+      virtual void setShimmerGradientColors(const std::optional<std::vector<std::string>>& shimmerGradientColors) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Skeleton";
+  };
+
+} // namespace margelo::nitro::skeleton

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

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

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

@@ -0,0 +1,110 @@
+///
+/// HybridSkeletonComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 <string>
+#include <vector>
+#include <memory>
+#include "HybridSkeletonSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::skeleton::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridSkeletonComponentName[];
+
+  /**
+   * Props for the "Skeleton" View.
+   */
+  class HybridSkeletonProps final: public react::ViewProps {
+  public:
+    HybridSkeletonProps() = default;
+    HybridSkeletonProps(const HybridSkeletonProps&);
+    HybridSkeletonProps(const react::PropsParserContext& context,
+                        const HybridSkeletonProps& sourceProps,
+                        const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<double>> shimmerSpeed;
+    CachedProp<std::optional<std::vector<std::string>>> shimmerGradientColors;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridSkeletonSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "Skeleton" View.
+   */
+  class HybridSkeletonState final {
+  public:
+    HybridSkeletonState() = default;
+
+  public:
+    void setProps(const HybridSkeletonProps& props) { _props.emplace(props); }
+    const std::optional<HybridSkeletonProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridSkeletonState(const HybridSkeletonState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridSkeletonState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridSkeletonState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridSkeletonProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "Skeleton" View.
+   */
+  using HybridSkeletonShadowNode = react::ConcreteViewShadowNode<HybridSkeletonComponentName /* "HybridSkeleton" */,
+                                                                 HybridSkeletonProps /* custom props */,
+                                                                 react::ViewEventEmitter /* default */,
+                                                                 HybridSkeletonState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "Skeleton" View.
+   */
+  class HybridSkeletonComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridSkeletonShadowNode> {
+  public:
+    HybridSkeletonComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridSkeletonProps`.
+     */
+    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 "Skeleton" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::skeleton::views

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

@@ -0,0 +1,11 @@
+{
+  "uiViewClassName": "Skeleton",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "shimmerSpeed": true,
+    "shimmerGradientColors": true,
+    "hybridRef": true
+  }
+}

package/lib/typescript/package.json

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

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

@@ -0,0 +1,9 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export interface SkeletonProps extends HybridViewProps {
+    shimmerSpeed?: number;
+    shimmerGradientColors?: string[];
+}
+export interface SkeletonMethods extends HybridViewMethods {
+}
+export type Skeleton = HybridView<SkeletonProps, SkeletonMethods>;
+//# sourceMappingURL=Skeleton.nitro.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton.nitro.d.ts","sourceRoot":"","sources":["../../../src/Skeleton.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;AACD,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;CAAG;AAE7D,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { SkeletonMethods, SkeletonProps } from './Skeleton.nitro';
+export declare const SkeletonView: import("react-native-nitro-modules").ReactNativeView<SkeletonProps, SkeletonMethods>;
+//# 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,eAAe,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEvE,eAAO,MAAM,YAAY,sFAGxB,CAAC"}

package/nitro.json

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

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

@@ -0,0 +1,85 @@
+///
+/// JHybridSkeletonSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSkeletonSpec.hpp"
+
+
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::skeleton {
+
+  jni::local_ref<JHybridSkeletonSpec::jhybriddata> JHybridSkeletonSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridSkeletonSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridSkeletonSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridSkeletonSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridSkeletonSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridSkeletonSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<double> JHybridSkeletonSpec::getShimmerSpeed() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getShimmerSpeed");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridSkeletonSpec::setShimmerSpeed(std::optional<double> shimmerSpeed) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* shimmerSpeed */)>("setShimmerSpeed");
+    method(_javaPart, shimmerSpeed.has_value() ? jni::JDouble::valueOf(shimmerSpeed.value()) : nullptr);
+  }
+  std::optional<std::vector<std::string>> JHybridSkeletonSpec::getShimmerGradientColors() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getShimmerGradientColors");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridSkeletonSpec::setShimmerGradientColors(const std::optional<std::vector<std::string>>& shimmerGradientColors) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* shimmerGradientColors */)>("setShimmerGradientColors");
+    method(_javaPart, shimmerGradientColors.has_value() ? [&]() {
+      size_t __size = shimmerGradientColors.value().size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = shimmerGradientColors.value()[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::skeleton

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

@@ -0,0 +1,68 @@
+///
+/// HybridSkeletonSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridSkeletonSpec.hpp"
+
+
+
+
+namespace margelo::nitro::skeleton {
+
+  using namespace facebook;
+
+  class JHybridSkeletonSpec: public jni::HybridClass<JHybridSkeletonSpec, JHybridObject>,
+                             public virtual HybridSkeletonSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/skeleton/HybridSkeletonSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridSkeletonSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridSkeletonSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridSkeletonSpec() 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<JHybridSkeletonSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<double> getShimmerSpeed() override;
+    void setShimmerSpeed(std::optional<double> shimmerSpeed) override;
+    std::optional<std::vector<std::string>> getShimmerGradientColors() override;
+    void setShimmerGradientColors(const std::optional<std::vector<std::string>>& shimmerGradientColors) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridSkeletonSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::skeleton

package/nitrogen/generated/android/c++/views/JHybridSkeletonStateUpdater.cpp

@@ -0,0 +1,60 @@
+///
+/// JHybridSkeletonStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSkeletonStateUpdater.hpp"
+#include "views/HybridSkeletonComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::skeleton::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridSkeletonState>;
+
+void JHybridSkeletonStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridSkeletonSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridSkeletonSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridSkeletonState& data = concreteState->getData();
+  const std::optional<HybridSkeletonProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridSkeletonState's data doesn't contain any props!");
+  }
+  const HybridSkeletonProps& props = maybeProps.value();
+  if (props.shimmerSpeed.isDirty) {
+    view->setShimmerSpeed(props.shimmerSpeed.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.shimmerGradientColors.isDirty) {
+    view->setShimmerGradientColors(props.shimmerGradientColors.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridSkeletonSpec> shared = javaView->cthis()->shared_cast<JHybridSkeletonSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::skeleton::views

package/nitrogen/generated/android/c++/views/JHybridSkeletonStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridSkeletonStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error skeleton was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridSkeletonSpec.hpp"
+#include "views/HybridSkeletonComponent.hpp"
+
+namespace margelo::nitro::skeleton::views {
+
+using namespace facebook;
+
+class JHybridSkeletonStateUpdater: public jni::JavaClass<JHybridSkeletonStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/skeleton/views/HybridSkeletonStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridSkeletonSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridSkeletonStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridSkeletonComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::skeleton::views

package/nitrogen/generated/android/kotlin/com/margelo/nitro/skeleton/HybridSkeletonSpec.kt

@@ -0,0 +1,65 @@
+///
+/// HybridSkeletonSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.skeleton
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.HybridView
+
+/**
+ * A Kotlin class representing the Skeleton HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of Skeleton.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridSkeletonSpec: HybridView() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject Skeleton]"
+  }
+
+  // Properties
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var shimmerSpeed: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var shimmerGradientColors: Array<String>?
+
+  // Methods
+  
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridSkeletonSpec"
+  }
+}