@onekeyfe/react-native-image 3.0.98

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

@@ -0,0 +1,84 @@
+///
+/// OneKeyImageContentFit.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * An enum which can be represented as a JavaScript union (OneKeyImageContentFit).
+   */
+  enum class OneKeyImageContentFit {
+    COVER      SWIFT_NAME(cover) = 0,
+    CONTAIN      SWIFT_NAME(contain) = 1,
+    FILL      SWIFT_NAME(fill) = 2,
+    CENTER      SWIFT_NAME(center) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImageContentFit <> JS OneKeyImageContentFit (union)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImageContentFit> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImageContentFit 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("cover"): return margelo::nitro::onekeyimage::OneKeyImageContentFit::COVER;
+        case hashString("contain"): return margelo::nitro::onekeyimage::OneKeyImageContentFit::CONTAIN;
+        case hashString("fill"): return margelo::nitro::onekeyimage::OneKeyImageContentFit::FILL;
+        case hashString("center"): return margelo::nitro::onekeyimage::OneKeyImageContentFit::CENTER;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OneKeyImageContentFit - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::onekeyimage::OneKeyImageContentFit arg) {
+      switch (arg) {
+        case margelo::nitro::onekeyimage::OneKeyImageContentFit::COVER: return JSIConverter<std::string>::toJSI(runtime, "cover");
+        case margelo::nitro::onekeyimage::OneKeyImageContentFit::CONTAIN: return JSIConverter<std::string>::toJSI(runtime, "contain");
+        case margelo::nitro::onekeyimage::OneKeyImageContentFit::FILL: return JSIConverter<std::string>::toJSI(runtime, "fill");
+        case margelo::nitro::onekeyimage::OneKeyImageContentFit::CENTER: return JSIConverter<std::string>::toJSI(runtime, "center");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert OneKeyImageContentFit 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("cover"):
+        case hashString("contain"):
+        case hashString("fill"):
+        case hashString("center"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// OneKeyImageLoadingStrategy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * An enum which can be represented as a JavaScript union (OneKeyImageLoadingStrategy).
+   */
+  enum class OneKeyImageLoadingStrategy {
+    STATIC      SWIFT_NAME(static) = 0,
+    SKELETON      SWIFT_NAME(skeleton) = 1,
+    NONE      SWIFT_NAME(none) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImageLoadingStrategy <> JS OneKeyImageLoadingStrategy (union)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy 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("static"): return margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::STATIC;
+        case hashString("skeleton"): return margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::SKELETON;
+        case hashString("none"): return margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::NONE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OneKeyImageLoadingStrategy - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy arg) {
+      switch (arg) {
+        case margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::STATIC: return JSIConverter<std::string>::toJSI(runtime, "static");
+        case margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::SKELETON: return JSIConverter<std::string>::toJSI(runtime, "skeleton");
+        case margelo::nitro::onekeyimage::OneKeyImageLoadingStrategy::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert OneKeyImageLoadingStrategy 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("static"):
+        case hashString("skeleton"):
+        case hashString("none"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,114 @@
+///
+/// OneKeyImagePreloadSource.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/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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+
+#include <string>
+#include <optional>
+#include "OneKeyImageCachePolicy.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * A struct which can be represented as a JavaScript object (OneKeyImagePreloadSource).
+   */
+  struct OneKeyImagePreloadSource final {
+  public:
+    std::string uri     SWIFT_PRIVATE;
+    std::optional<std::string> headersJson     SWIFT_PRIVATE;
+    std::optional<OneKeyImageCachePolicy> cachePolicy     SWIFT_PRIVATE;
+    std::optional<double> resizeWidth     SWIFT_PRIVATE;
+    std::optional<double> resizeHeight     SWIFT_PRIVATE;
+    std::optional<double> pixelRatio     SWIFT_PRIVATE;
+    std::optional<double> overscan     SWIFT_PRIVATE;
+    std::optional<bool> optimizeTos     SWIFT_PRIVATE;
+
+  public:
+    OneKeyImagePreloadSource() = default;
+    explicit OneKeyImagePreloadSource(std::string uri, std::optional<std::string> headersJson, std::optional<OneKeyImageCachePolicy> cachePolicy, std::optional<double> resizeWidth, std::optional<double> resizeHeight, std::optional<double> pixelRatio, std::optional<double> overscan, std::optional<bool> optimizeTos): uri(uri), headersJson(headersJson), cachePolicy(cachePolicy), resizeWidth(resizeWidth), resizeHeight(resizeHeight), pixelRatio(pixelRatio), overscan(overscan), optimizeTos(optimizeTos) {}
+
+  public:
+    friend bool operator==(const OneKeyImagePreloadSource& lhs, const OneKeyImagePreloadSource& rhs) = default;
+  };
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImagePreloadSource <> JS OneKeyImagePreloadSource (object)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImagePreloadSource> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImagePreloadSource fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::onekeyimage::OneKeyImagePreloadSource(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headersJson"))),
+        JSIConverter<std::optional<margelo::nitro::onekeyimage::OneKeyImageCachePolicy>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cachePolicy"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resizeWidth"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resizeHeight"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pixelRatio"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "overscan"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "optimizeTos")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::onekeyimage::OneKeyImagePreloadSource& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "uri"), JSIConverter<std::string>::toJSI(runtime, arg.uri));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "headersJson"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.headersJson));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cachePolicy"), JSIConverter<std::optional<margelo::nitro::onekeyimage::OneKeyImageCachePolicy>>::toJSI(runtime, arg.cachePolicy));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "resizeWidth"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.resizeWidth));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "resizeHeight"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.resizeHeight));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "pixelRatio"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.pixelRatio));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "overscan"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.overscan));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "optimizeTos"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.optimizeTos));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "uri")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headersJson")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::onekeyimage::OneKeyImageCachePolicy>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cachePolicy")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resizeWidth")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resizeHeight")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pixelRatio")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "overscan")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "optimizeTos")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,84 @@
+///
+/// OneKeyImageVariant.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * An enum which can be represented as a JavaScript union (OneKeyImageVariant).
+   */
+  enum class OneKeyImageVariant {
+    GENERIC      SWIFT_NAME(generic) = 0,
+    TOKEN      SWIFT_NAME(token) = 1,
+    NETWORK      SWIFT_NAME(network) = 2,
+    AVATAR      SWIFT_NAME(avatar) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImageVariant <> JS OneKeyImageVariant (union)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImageVariant> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImageVariant 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("generic"): return margelo::nitro::onekeyimage::OneKeyImageVariant::GENERIC;
+        case hashString("token"): return margelo::nitro::onekeyimage::OneKeyImageVariant::TOKEN;
+        case hashString("network"): return margelo::nitro::onekeyimage::OneKeyImageVariant::NETWORK;
+        case hashString("avatar"): return margelo::nitro::onekeyimage::OneKeyImageVariant::AVATAR;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OneKeyImageVariant - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::onekeyimage::OneKeyImageVariant arg) {
+      switch (arg) {
+        case margelo::nitro::onekeyimage::OneKeyImageVariant::GENERIC: return JSIConverter<std::string>::toJSI(runtime, "generic");
+        case margelo::nitro::onekeyimage::OneKeyImageVariant::TOKEN: return JSIConverter<std::string>::toJSI(runtime, "token");
+        case margelo::nitro::onekeyimage::OneKeyImageVariant::NETWORK: return JSIConverter<std::string>::toJSI(runtime, "network");
+        case margelo::nitro::onekeyimage::OneKeyImageVariant::AVATAR: return JSIConverter<std::string>::toJSI(runtime, "avatar");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert OneKeyImageVariant 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("generic"):
+        case hashString("token"):
+        case hashString("network"):
+        case hashString("avatar"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,62 @@
+///
+/// HybridOneKeyImageComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneKeyImageComponent.hpp"
+
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/ReactProp.hpp>
+
+namespace margelo::nitro::onekeyimage::views {
+
+  using namespace facebook;
+
+  extern const char HybridOneKeyImageComponentName[] = "OneKeyImage";
+
+  HybridOneKeyImageProps::HybridOneKeyImageProps(const react::PropsParserContext& context,
+                                                 const HybridOneKeyImageProps& sourceProps,
+                                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    sourceUri(nitro::ReactProp<std::optional<std::string>>::fromRawValue("OneKeyImage", "sourceUri", rawProps, sourceProps.sourceUri)),
+    sourceHeadersJson(nitro::ReactProp<std::optional<std::string>>::fromRawValue("OneKeyImage", "sourceHeadersJson", rawProps, sourceProps.sourceHeadersJson)),
+    variant(nitro::ReactProp<std::optional<OneKeyImageVariant>>::fromRawValue("OneKeyImage", "variant", rawProps, sourceProps.variant)),
+    contentFit(nitro::ReactProp<std::optional<OneKeyImageContentFit>>::fromRawValue("OneKeyImage", "contentFit", rawProps, sourceProps.contentFit)),
+    cachePolicy(nitro::ReactProp<std::optional<OneKeyImageCachePolicy>>::fromRawValue("OneKeyImage", "cachePolicy", rawProps, sourceProps.cachePolicy)),
+    autoplay(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "autoplay", rawProps, sourceProps.autoplay)),
+    recyclingKey(nitro::ReactProp<std::optional<std::string>>::fromRawValue("OneKeyImage", "recyclingKey", rawProps, sourceProps.recyclingKey)),
+    optimizeTos(nitro::ReactProp<std::optional<bool>>::fromRawValue("OneKeyImage", "optimizeTos", rawProps, sourceProps.optimizeTos)),
+    overscan(nitro::ReactProp<std::optional<double>>::fromRawValue("OneKeyImage", "overscan", rawProps, sourceProps.overscan)),
+    loadingStrategy(nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>>::fromRawValue("OneKeyImage", "loadingStrategy", rawProps, sourceProps.loadingStrategy)),
+    onLoadStart(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("OneKeyImage", "onLoadStart", rawProps, sourceProps.onLoadStart)),
+    onLoad(nitro::ReactProp<std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>>::fromRawValue("OneKeyImage", "onLoad", rawProps, sourceProps.onLoad)),
+    onDisplay(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("OneKeyImage", "onDisplay", rawProps, sourceProps.onDisplay)),
+    onError(nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>>::fromRawValue("OneKeyImage", "onError", rawProps, sourceProps.onError)),
+    onLoadEnd(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("OneKeyImage", "onLoadEnd", rawProps, sourceProps.onLoadEnd)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridOneKeyImageSpec>& /* ref */)>>>::fromRawValue("OneKeyImage", "hybridRef", rawProps, sourceProps.hybridRef)) { }
+
+  bool HybridOneKeyImageProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("sourceUri"): return true;
+      case hashString("sourceHeadersJson"): return true;
+      case hashString("variant"): return true;
+      case hashString("contentFit"): return true;
+      case hashString("cachePolicy"): return true;
+      case hashString("autoplay"): return true;
+      case hashString("recyclingKey"): return true;
+      case hashString("optimizeTos"): return true;
+      case hashString("overscan"): return true;
+      case hashString("loadingStrategy"): return true;
+      case hashString("onLoadStart"): return true;
+      case hashString("onLoad"): return true;
+      case hashString("onDisplay"): return true;
+      case hashString("onError"): return true;
+      case hashString("onLoadEnd"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+} // namespace margelo::nitro::onekeyimage::views

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

@@ -0,0 +1,132 @@
+///
+/// HybridOneKeyImageComponent.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/ReactProp.hpp>
+#include <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
+
+#include <string>
+#include <optional>
+#include "OneKeyImageVariant.hpp"
+#include "OneKeyImageContentFit.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include "OneKeyImageLoadingStrategy.hpp"
+#include <functional>
+#include "OneKeyImageCacheType.hpp"
+#include <memory>
+#include "HybridOneKeyImageSpec.hpp"
+
+namespace margelo::nitro::onekeyimage::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridOneKeyImageComponentName[];
+
+  /**
+   * Props for the "OneKeyImage" View.
+   */
+  class HybridOneKeyImageProps final: public react::ViewProps {
+  public:
+    HybridOneKeyImageProps() = default;
+    HybridOneKeyImageProps(const react::PropsParserContext& context,
+                           const HybridOneKeyImageProps& sourceProps,
+                           const react::RawProps& rawProps);
+
+  public:
+    nitro::ReactProp<std::optional<std::string>> sourceUri;
+    nitro::ReactProp<std::optional<std::string>> sourceHeadersJson;
+    nitro::ReactProp<std::optional<OneKeyImageVariant>> variant;
+    nitro::ReactProp<std::optional<OneKeyImageContentFit>> contentFit;
+    nitro::ReactProp<std::optional<OneKeyImageCachePolicy>> cachePolicy;
+    nitro::ReactProp<std::optional<bool>> autoplay;
+    nitro::ReactProp<std::optional<std::string>> recyclingKey;
+    nitro::ReactProp<std::optional<bool>> optimizeTos;
+    nitro::ReactProp<std::optional<double>> overscan;
+    nitro::ReactProp<std::optional<OneKeyImageLoadingStrategy>> loadingStrategy;
+    nitro::ReactProp<std::optional<std::function<void()>>> onLoadStart;
+    nitro::ReactProp<std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>> onLoad;
+    nitro::ReactProp<std::optional<std::function<void()>>> onDisplay;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>> onError;
+    nitro::ReactProp<std::optional<std::function<void()>>> onLoadEnd;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridOneKeyImageSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridOneKeyImageProps& other) const noexcept {
+      return sourceUri.hasSameValue(other.sourceUri) &&
+             sourceHeadersJson.hasSameValue(other.sourceHeadersJson) &&
+             variant.hasSameValue(other.variant) &&
+             contentFit.hasSameValue(other.contentFit) &&
+             cachePolicy.hasSameValue(other.cachePolicy) &&
+             autoplay.hasSameValue(other.autoplay) &&
+             recyclingKey.hasSameValue(other.recyclingKey) &&
+             optimizeTos.hasSameValue(other.optimizeTos) &&
+             overscan.hasSameValue(other.overscan) &&
+             loadingStrategy.hasSameValue(other.loadingStrategy) &&
+             onLoadStart.hasSameValue(other.onLoadStart) &&
+             onLoad.hasSameValue(other.onLoad) &&
+             onDisplay.hasSameValue(other.onDisplay) &&
+             onError.hasSameValue(other.onError) &&
+             onLoadEnd.hasSameValue(other.onLoadEnd) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return sourceUri.isProvided() ||
+             sourceHeadersJson.isProvided() ||
+             variant.isProvided() ||
+             contentFit.isProvided() ||
+             cachePolicy.isProvided() ||
+             autoplay.isProvided() ||
+             recyclingKey.isProvided() ||
+             optimizeTos.isProvided() ||
+             overscan.isProvided() ||
+             loadingStrategy.isProvided() ||
+             onLoadStart.isProvided() ||
+             onLoad.isProvided() ||
+             onDisplay.isProvided() ||
+             onError.isProvided() ||
+             onLoadEnd.isProvided() ||
+             hybridRef.isProvided();
+    }
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "OneKeyImage" View.
+   */
+  using HybridOneKeyImageState = nitro::ViewPropsHolderState<HybridOneKeyImageProps>;
+
+  /**
+   * The Shadow Node for the "OneKeyImage" View.
+   */
+  using HybridOneKeyImageShadowNode = react::ConcreteViewShadowNode<HybridOneKeyImageComponentName /* "HybridOneKeyImage" */,
+                                                                    HybridOneKeyImageProps /* custom props */,
+                                                                    react::ViewEventEmitter /* default */,
+                                                                    HybridOneKeyImageState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "OneKeyImage" View.
+   */
+  using HybridOneKeyImageComponentDescriptor = nitro::ViewComponentDescriptor<HybridOneKeyImageShadowNode>;
+
+  /* The actual view for "OneKeyImage" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::onekeyimage::views

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

@@ -0,0 +1,24 @@
+{
+  "uiViewClassName": "OneKeyImage",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "sourceUri": true,
+    "sourceHeadersJson": true,
+    "variant": true,
+    "contentFit": true,
+    "cachePolicy": true,
+    "autoplay": true,
+    "recyclingKey": true,
+    "optimizeTos": true,
+    "overscan": true,
+    "loadingStrategy": true,
+    "onLoadStart": true,
+    "onLoad": true,
+    "onDisplay": true,
+    "onError": true,
+    "onLoadEnd": true,
+    "hybridRef": true
+  }
+}

package/lib/typescript/package.json

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

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

@@ -0,0 +1,67 @@
+import type { HybridObject, HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export declare enum OneKeyImageVariant {
+    GENERIC = "generic",
+    TOKEN = "token",
+    NETWORK = "network",
+    AVATAR = "avatar"
+}
+export declare enum OneKeyImageContentFit {
+    COVER = "cover",
+    CONTAIN = "contain",
+    FILL = "fill",
+    CENTER = "center"
+}
+export declare enum OneKeyImageCachePolicy {
+    MEMORY_DISK = "memory-disk",
+    MEMORY = "memory",
+    DISK = "disk",
+    NONE = "none"
+}
+export type OneKeyImageCacheType = 'none' | 'memory' | 'disk';
+export declare enum OneKeyImageLoadingStrategy {
+    STATIC = "static",
+    SKELETON = "skeleton",
+    NONE = "none"
+}
+export interface OneKeyImageNativeProps extends HybridViewProps {
+    sourceUri?: string;
+    sourceHeadersJson?: string;
+    variant?: OneKeyImageVariant;
+    contentFit?: OneKeyImageContentFit;
+    cachePolicy?: OneKeyImageCachePolicy;
+    autoplay?: boolean;
+    recyclingKey?: string;
+    optimizeTos?: boolean;
+    overscan?: number;
+    loadingStrategy?: OneKeyImageLoadingStrategy;
+    onLoadStart?: () => void;
+    onLoad?: (width: number, height: number, cacheType: OneKeyImageCacheType) => void;
+    onDisplay?: () => void;
+    onError?: (message: string) => void;
+    onLoadEnd?: () => void;
+}
+export interface OneKeyImageMethods extends HybridViewMethods {
+    reload(): void;
+    cancel(): void;
+}
+export interface OneKeyImagePreloadSource {
+    uri: string;
+    headersJson?: string;
+    cachePolicy?: OneKeyImageCachePolicy;
+    resizeWidth?: number;
+    resizeHeight?: number;
+    pixelRatio?: number;
+    overscan?: number;
+    optimizeTos?: boolean;
+}
+export interface OneKeyImageCache extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    preload(sources: OneKeyImagePreloadSource[]): Promise<boolean>;
+    clearMemory(): Promise<void>;
+    clearDisk(): Promise<void>;
+    clearAll(): Promise<void>;
+}
+export type OneKeyImage = HybridView<OneKeyImageNativeProps, OneKeyImageMethods>;
+//# sourceMappingURL=OneKeyImage.nitro.d.ts.map