@onekeyfe/react-native-image 6.7.0-alpha.414 → 6.7.0-alpha.418

package/lib/nitrogen/generated/android/c++/JHybridOneKeyIconSpec.cpp

@@ -0,0 +1,67 @@
+///
+/// JHybridOneKeyIconSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyIconSpec.hpp"
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::onekeyimage {
+
+  std::shared_ptr<JHybridOneKeyIconSpec> JHybridOneKeyIconSpec::JavaPart::getJHybridOneKeyIconSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridOneKeyIconSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridOneKeyIconSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridOneKeyIconSpec::CxxPart::jhybriddata> JHybridOneKeyIconSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridOneKeyIconSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridOneKeyIconSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridOneKeyIconSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridOneKeyIconSpec>(castJavaPart);
+  }
+
+  void JHybridOneKeyIconSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridOneKeyIconSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::optional<std::string> JHybridOneKeyIconSpec::getIconName() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getIconName");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridOneKeyIconSpec::setIconName(const std::optional<std::string>& iconName) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* iconName */)>("setIconName");
+    method(_javaPart, iconName.has_value() ? jni::make_jstring(iconName.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridOneKeyIconSpec::getResolvedColor() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getResolvedColor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridOneKeyIconSpec::setResolvedColor(const std::optional<std::string>& resolvedColor) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* resolvedColor */)>("setResolvedColor");
+    method(_javaPart, resolvedColor.has_value() ? jni::make_jstring(resolvedColor.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JHybridOneKeyIconSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridOneKeyIconSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridOneKeyIconSpec.hpp"
+
+
+
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  class JHybridOneKeyIconSpec: public virtual HybridOneKeyIconSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyIconSpec;";
+      std::shared_ptr<JHybridOneKeyIconSpec> getJHybridOneKeyIconSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyIconSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridOneKeyIconSpec(const jni::local_ref<JHybridOneKeyIconSpec::JavaPart>& javaPart):
+      HybridObject(HybridOneKeyIconSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridOneKeyIconSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridOneKeyIconSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getIconName() override;
+    void setIconName(const std::optional<std::string>& iconName) override;
+    std::optional<std::string> getResolvedColor() override;
+    void setResolvedColor(const std::optional<std::string>& resolvedColor) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    jni::global_ref<JHybridOneKeyIconSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/views/JHybridOneKeyIconStateUpdater.cpp

@@ -0,0 +1,79 @@
+///
+/// JHybridOneKeyIconStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyIconStateUpdater.hpp"
+#include "views/HybridOneKeyIconComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::onekeyimage::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridOneKeyIconState>;
+
+std::shared_ptr<const HybridOneKeyIconProps> JHybridOneKeyIconStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
+  }
+  auto concreteState = std::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridOneKeyIconState& data = concreteState->getData();
+  const std::shared_ptr<const HybridOneKeyIconProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    throw std::runtime_error("HybridOneKeyIconState's data doesn't contain any props!");
+  }
+  return props;
+}
+
+void JHybridOneKeyIconStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridOneKeyIconSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridOneKeyIconSpec> hybridView = javaView->getJHybridOneKeyIconSpec();
+  std::shared_ptr<const HybridOneKeyIconProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridOneKeyIconProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->iconName.isProvided()
+        : !newProps->iconName.hasSameValue(oldProps->iconName)) {
+    hybridView->setIconName(newProps->iconName.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->resolvedColor.isProvided()
+        : !newProps->resolvedColor.hasSameValue(oldProps->resolvedColor)) {
+    hybridView->setResolvedColor(newProps->resolvedColor.get());
+  }
+
+  // Update hybridRef if it changed
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newProps->hybridRef.get();
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(hybridView);
+    }
+  }
+}
+
+} // namespace margelo::nitro::onekeyimage::views

package/lib/nitrogen/generated/android/c++/views/JHybridOneKeyIconStateUpdater.hpp

@@ -0,0 +1,54 @@
+///
+/// JHybridOneKeyIconStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error onekeyimage 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/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridOneKeyIconSpec.hpp"
+#include "views/HybridOneKeyIconComponent.hpp"
+
+namespace margelo::nitro::onekeyimage::views {
+
+using namespace facebook;
+
+class JHybridOneKeyIconStateUpdater final: public jni::JavaClass<JHybridOneKeyIconStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/views/HybridOneKeyIconStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridOneKeyIconSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridOneKeyIconProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridOneKeyIconStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridOneKeyIconComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::onekeyimage::views

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/HybridOneKeyIconSpec.kt

@@ -0,0 +1,65 @@
+///
+/// HybridOneKeyIconSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.onekeyimage
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+import com.margelo.nitro.core.HybridObject
+import com.margelo.nitro.views.HybridView
+
+/**
+ * A Kotlin class representing the OneKeyIcon HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of OneKeyIcon.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridOneKeyIconSpec: HybridView() {
+  // Properties
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var iconName: String?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var resolvedColor: String?
+
+  // Methods
+  
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject OneKeyIcon]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridOneKeyIconSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridOneKeyIconSpec::CxxPart::initHybrid(...)
+    @FastNative
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridOneKeyIconSpec"
+  }
+}

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/views/HybridOneKeyIconManager.kt

@@ -0,0 +1,96 @@
+///
+/// HybridOneKeyIconManager.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.onekeyimage.views
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.R.id.associated_hybrid_view_tag
+import com.margelo.nitro.views.RecyclableView
+import com.margelo.nitro.onekeyimage.*
+
+/**
+ * Represents the React Native `ViewManager` for the "OneKeyIcon" Nitro HybridView.
+ */
+public class HybridOneKeyIconManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridOneKeyIcon,
+    var lastState: StateWrapper? = null,
+  )
+
+  init {
+    if (RecyclableView::class.java.isAssignableFrom(HybridOneKeyIcon::class.java)) {
+      // Enable view recycling
+      super.setupViewRecycling()
+    }
+  }
+
+  override fun getName(): String {
+    return "OneKeyIcon"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View {
+    val hybridView = HybridOneKeyIcon(reactContext)
+    val view = hybridView.view
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
+    return view
+  }
+
+  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val holder = getHybridViewHolder(view)
+      ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
+
+    // 1. Update each prop individually
+    hybridView.beforeUpdate()
+    HybridOneKeyIconStateUpdater.updateViewProps(hybridView, newState, oldState)
+    hybridView.afterUpdate()
+    holder.lastState = newState
+
+    // 2. Continue in base View props
+    return super.updateState(view, props, newState)
+  }
+
+  override fun onDropViewInstance(view: View) {
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
+    return super.onDropViewInstance(view)
+  }
+
+  protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+      ?: return null
+    val holder = getHybridViewHolder(preparedView)
+      ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
+
+    @Suppress("USELESS_IS_CHECK")
+    if (hybridView is RecyclableView) {
+      // Recycle in it's implementation
+      hybridView.prepareForRecycle()
+
+      // Maybe update the view if it changed
+      return hybridView.view
+    } else {
+      return null
+    }
+  }
+
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
+  }
+}

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/views/HybridOneKeyIconStateUpdater.kt

@@ -0,0 +1,23 @@
+///
+/// HybridOneKeyIconStateUpdater.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.onekeyimage.views
+
+import com.facebook.react.uimanager.StateWrapper
+import com.margelo.nitro.onekeyimage.*
+
+internal class HybridOneKeyIconStateUpdater {
+  companion object {
+    /**
+     * Updates the props for [view] through C++.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
+     */
+    @Suppress("KotlinJniMissingFunction")
+    @JvmStatic
+    external fun updateViewProps(view: HybridOneKeyIconSpec, newState: StateWrapper, oldState: StateWrapper?)
+  }
+}

package/lib/nitrogen/generated/android/onekeyimage+autolinking.cmake

@@ -33,10 +33,14 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/onekeyimageOnLoad.cpp
   # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridOneKeyIconSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridOneKeyIconComponent.cpp
   ../nitrogen/generated/shared/c++/HybridOneKeyImageCacheSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOneKeyImageSpec.cpp
   ../nitrogen/generated/shared/c++/views/HybridOneKeyImageComponent.cpp
   # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridOneKeyIconSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridOneKeyIconStateUpdater.cpp
   ../nitrogen/generated/android/c++/JHybridOneKeyImageCacheSpec.cpp
   ../nitrogen/generated/android/c++/JHybridOneKeyImageSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridOneKeyImageStateUpdater.cpp

package/lib/nitrogen/generated/android/onekeyimageOnLoad.cpp

@@ -15,6 +15,8 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "JHybridOneKeyIconSpec.hpp"
+#include "views/JHybridOneKeyIconStateUpdater.hpp"
 #include "JHybridOneKeyImageCacheSpec.hpp"
 #include "JHybridOneKeyImageSpec.hpp"
 #include "JFunc_void.hpp"
@@ -47,12 +49,22 @@ struct JHybridOneKeyImageCacheSpecImpl: public jni::JavaClass<JHybridOneKeyImage
     return javaPart->getJHybridOneKeyImageCacheSpec();
   }
 };
+struct JHybridOneKeyIconSpecImpl: public jni::JavaClass<JHybridOneKeyIconSpecImpl, JHybridOneKeyIconSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyIcon;";
+  static std::shared_ptr<JHybridOneKeyIconSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridOneKeyIconSpecImpl::javaobject()>();
+    jni::local_ref<JHybridOneKeyIconSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridOneKeyIconSpec();
+  }
+};
 
 void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::onekeyimage;
 
   // Register native JNI methods
+  margelo::nitro::onekeyimage::JHybridOneKeyIconSpec::CxxPart::registerNatives();
+  margelo::nitro::onekeyimage::views::JHybridOneKeyIconStateUpdater::registerNatives();
   margelo::nitro::onekeyimage::JHybridOneKeyImageCacheSpec::CxxPart::registerNatives();
   margelo::nitro::onekeyimage::JHybridOneKeyImageSpec::CxxPart::registerNatives();
   margelo::nitro::onekeyimage::JFunc_void_cxx::registerNatives();
@@ -73,6 +85,12 @@ void registerAllNatives() {
       return JHybridOneKeyImageCacheSpecImpl::create();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OneKeyIcon",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridOneKeyIconSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/ios/OneKeyImage-Swift-Cxx-Bridge.cpp

@@ -8,6 +8,7 @@
 #include "OneKeyImage-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
+#include "HybridOneKeyIconSpecSwift.hpp"
 #include "HybridOneKeyImageCacheSpecSwift.hpp"
 #include "HybridOneKeyImageSpecSwift.hpp"
 #include "OneKeyImage-Swift-Cxx-Umbrella.hpp"
@@ -15,6 +16,22 @@
 
 namespace margelo::nitro::onekeyimage::bridge::swift {
 
+  // pragma MARK: std::shared_ptr<HybridOneKeyIconSpec>
+  std::shared_ptr<HybridOneKeyIconSpec> create_std__shared_ptr_HybridOneKeyIconSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    OneKeyImage::HybridOneKeyIconSpec_cxx swiftPart = OneKeyImage::HybridOneKeyIconSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::onekeyimage::HybridOneKeyIconSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridOneKeyIconSpec_(std__shared_ptr_HybridOneKeyIconSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::onekeyimage::HybridOneKeyIconSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::onekeyimage::HybridOneKeyIconSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridOneKeyIconSpec\" is not implemented in Swift!");
+    }
+    #endif
+    OneKeyImage::HybridOneKeyIconSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::function<void(bool /* result */)>
   Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = OneKeyImage::Func_void_bool::fromUnsafe(swiftClosureWrapper);

package/lib/nitrogen/generated/ios/OneKeyImage-Swift-Cxx-Bridge.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `HybridOneKeyIconSpec` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { class HybridOneKeyIconSpec; }
 // Forward declaration of `HybridOneKeyImageCacheSpec` to properly resolve imports.
 namespace margelo::nitro::onekeyimage { class HybridOneKeyImageCacheSpec; }
 // Forward declaration of `HybridOneKeyImageSpec` to properly resolve imports.
@@ -26,12 +28,15 @@ namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
 namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridOneKeyIconSpec_cxx` to properly resolve imports.
+namespace OneKeyImage { class HybridOneKeyIconSpec_cxx; }
 // Forward declaration of `HybridOneKeyImageCacheSpec_cxx` to properly resolve imports.
 namespace OneKeyImage { class HybridOneKeyImageCacheSpec_cxx; }
 // Forward declaration of `HybridOneKeyImageSpec_cxx` to properly resolve imports.
 namespace OneKeyImage { class HybridOneKeyImageSpec_cxx; }
 
 // Include C++ defined types
+#include "HybridOneKeyIconSpec.hpp"
 #include "HybridOneKeyImageCacheSpec.hpp"
 #include "HybridOneKeyImageSpec.hpp"
 #include "OneKeyImageCachePolicy.hpp"
@@ -56,6 +61,33 @@ namespace OneKeyImage { class HybridOneKeyImageSpec_cxx; }
  */
 namespace margelo::nitro::onekeyimage::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridOneKeyIconSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridOneKeyIconSpec>`.
+   */
+  using std__shared_ptr_HybridOneKeyIconSpec_ = std::shared_ptr<HybridOneKeyIconSpec>;
+  std::shared_ptr<HybridOneKeyIconSpec> create_std__shared_ptr_HybridOneKeyIconSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridOneKeyIconSpec_(std__shared_ptr_HybridOneKeyIconSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridOneKeyIconSpec>
+  using std__weak_ptr_HybridOneKeyIconSpec_ = std::weak_ptr<HybridOneKeyIconSpec>;
+  inline std__weak_ptr_HybridOneKeyIconSpec_ weakify_std__shared_ptr_HybridOneKeyIconSpec_(const std::shared_ptr<HybridOneKeyIconSpec>& strong) noexcept { return strong; }
+  
   // pragma MARK: std::shared_ptr<Promise<bool>>
   /**
    * Specialized version of `std::shared_ptr<Promise<bool>>`.
@@ -112,21 +144,6 @@ namespace margelo::nitro::onekeyimage::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::optional<OneKeyImageCachePolicy>
   /**
    * Specialized version of `std::optional<OneKeyImageCachePolicy>`.

package/lib/nitrogen/generated/ios/OneKeyImage-Swift-Cxx-Umbrella.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `HybridOneKeyIconSpec` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { class HybridOneKeyIconSpec; }
 // Forward declaration of `HybridOneKeyImageCacheSpec` to properly resolve imports.
 namespace margelo::nitro::onekeyimage { class HybridOneKeyImageCacheSpec; }
 // Forward declaration of `HybridOneKeyImageSpec` to properly resolve imports.
@@ -26,6 +28,7 @@ namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
 namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
 
 // Include C++ defined types
+#include "HybridOneKeyIconSpec.hpp"
 #include "HybridOneKeyImageCacheSpec.hpp"
 #include "HybridOneKeyImageSpec.hpp"
 #include "OneKeyImageCachePolicy.hpp"
@@ -53,6 +56,8 @@ namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridOneKeyIconSpec_cxx` to properly resolve imports.
+namespace OneKeyImage { class HybridOneKeyIconSpec_cxx; }
 // Forward declaration of `HybridOneKeyImageCacheSpec_cxx` to properly resolve imports.
 namespace OneKeyImage { class HybridOneKeyImageCacheSpec_cxx; }
 // Forward declaration of `HybridOneKeyImageSpec_cxx` to properly resolve imports.

package/lib/nitrogen/generated/ios/OneKeyImageAutolinking.mm

@@ -12,6 +12,7 @@
 
 #include "HybridOneKeyImageSpecSwift.hpp"
 #include "HybridOneKeyImageCacheSpecSwift.hpp"
+#include "HybridOneKeyIconSpecSwift.hpp"
 
 @interface OneKeyImageAutolinking : NSObject
 @end
@@ -36,6 +37,13 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OneKeyIcon",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridOneKeyIconSpec> hybridObject = OneKeyImage::OneKeyImageAutolinking::createOneKeyIcon();
+      return hybridObject;
+    }
+  );
 }
 
 @end