@onekeyfe/react-native-image 3.0.98

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

@@ -0,0 +1,71 @@
+///
+/// OneKeyImage-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HybridOneKeyImageCacheSpec` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { class HybridOneKeyImageCacheSpec; }
+// Forward declaration of `HybridOneKeyImageSpec` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { class HybridOneKeyImageSpec; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+// Forward declaration of `OneKeyImageCacheType` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCacheType; }
+// Forward declaration of `OneKeyImageContentFit` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageContentFit; }
+// Forward declaration of `OneKeyImageLoadingStrategy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageLoadingStrategy; }
+// Forward declaration of `OneKeyImagePreloadSource` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
+// Forward declaration of `OneKeyImageVariant` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
+
+// Include C++ defined types
+#include "HybridOneKeyImageCacheSpec.hpp"
+#include "HybridOneKeyImageSpec.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include "OneKeyImageCacheType.hpp"
+#include "OneKeyImageContentFit.hpp"
+#include "OneKeyImageLoadingStrategy.hpp"
+#include "OneKeyImagePreloadSource.hpp"
+#include "OneKeyImageVariant.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "OneKeyImage-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// 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 Swift defined types
+#if __has_include("OneKeyImage-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "OneKeyImage".
+#include "OneKeyImage-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<OneKeyImage/OneKeyImage-Swift.h>)
+#include <OneKeyImage/OneKeyImage-Swift.h>
+#else
+#error OneKeyImage's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "OneKeyImage", and try building the app first.
+#endif

package/nitrogen/generated/ios/OneKeyImageAutolinking.mm

@@ -0,0 +1,41 @@
+///
+/// OneKeyImageAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "OneKeyImage-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridOneKeyImageSpecSwift.hpp"
+#include "HybridOneKeyImageCacheSpecSwift.hpp"
+
+@interface OneKeyImageAutolinking : NSObject
+@end
+
+@implementation OneKeyImageAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::onekeyimage;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OneKeyImage",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridOneKeyImageSpec> hybridObject = OneKeyImage::OneKeyImageAutolinking::createOneKeyImage();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OneKeyImageCache",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridOneKeyImageCacheSpec> hybridObject = OneKeyImage::OneKeyImageAutolinking::createOneKeyImageCache();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/OneKeyImageAutolinking.swift

@@ -0,0 +1,38 @@
+///
+/// OneKeyImageAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class OneKeyImageAutolinking {
+  public typealias bridge = margelo.nitro.onekeyimage.bridge.swift
+
+  public static func createOneKeyImage() -> bridge.std__shared_ptr_HybridOneKeyImageSpec_ {
+    let hybridObject = HybridOneKeyImage()
+    return { () -> bridge.std__shared_ptr_HybridOneKeyImageSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isOneKeyImageRecyclable() -> Bool {
+    return HybridOneKeyImage.self is any RecyclableView.Type
+  }
+  
+  public static func createOneKeyImageCache() -> bridge.std__shared_ptr_HybridOneKeyImageCacheSpec_ {
+    let hybridObject = HybridOneKeyImageCache()
+    return { () -> bridge.std__shared_ptr_HybridOneKeyImageCacheSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isOneKeyImageCacheRecyclable() -> Bool {
+    return HybridOneKeyImageCache.self is any RecyclableView.Type
+  }
+}

package/nitrogen/generated/ios/c++/HybridOneKeyImageCacheSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridOneKeyImageCacheSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneKeyImageCacheSpecSwift.hpp"
+
+namespace margelo::nitro::onekeyimage {
+} // namespace margelo::nitro::onekeyimage

package/nitrogen/generated/ios/c++/HybridOneKeyImageCacheSpecSwift.hpp

@@ -0,0 +1,114 @@
+///
+/// HybridOneKeyImageCacheSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridOneKeyImageCacheSpec.hpp"
+
+// Forward declaration of `HybridOneKeyImageCacheSpec_cxx` to properly resolve imports.
+namespace OneKeyImage { class HybridOneKeyImageCacheSpec_cxx; }
+
+// Forward declaration of `OneKeyImagePreloadSource` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+
+#include <NitroModules/Promise.hpp>
+#include "OneKeyImagePreloadSource.hpp"
+#include <vector>
+#include <string>
+#include <optional>
+#include "OneKeyImageCachePolicy.hpp"
+
+#include "OneKeyImage-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * The C++ part of HybridOneKeyImageCacheSpec_cxx.swift.
+   *
+   * HybridOneKeyImageCacheSpecSwift (C++) accesses HybridOneKeyImageCacheSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridOneKeyImageCacheSpec_cxx can directly inherit from the C++ class HybridOneKeyImageCacheSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridOneKeyImageCacheSpecSwift: public virtual HybridOneKeyImageCacheSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridOneKeyImageCacheSpecSwift(const OneKeyImage::HybridOneKeyImageCacheSpec_cxx& swiftPart):
+      HybridObject(HybridOneKeyImageCacheSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline OneKeyImage::HybridOneKeyImageCacheSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridOneKeyImageCacheSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<bool>> preload(const std::vector<OneKeyImagePreloadSource>& sources) override {
+      auto __result = _swiftPart.preload(sources);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearMemory() override {
+      auto __result = _swiftPart.clearMemory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearDisk() override {
+      auto __result = _swiftPart.clearDisk();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> clearAll() override {
+      auto __result = _swiftPart.clearAll();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    OneKeyImage::HybridOneKeyImageCacheSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/nitrogen/generated/ios/c++/HybridOneKeyImageSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridOneKeyImageSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneKeyImageSpecSwift.hpp"
+
+namespace margelo::nitro::onekeyimage {
+} // namespace margelo::nitro::onekeyimage

package/nitrogen/generated/ios/c++/HybridOneKeyImageSpecSwift.hpp

@@ -0,0 +1,206 @@
+///
+/// HybridOneKeyImageSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridOneKeyImageSpec.hpp"
+
+// Forward declaration of `HybridOneKeyImageSpec_cxx` to properly resolve imports.
+namespace OneKeyImage { class HybridOneKeyImageSpec_cxx; }
+
+// Forward declaration of `OneKeyImageVariant` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
+// Forward declaration of `OneKeyImageContentFit` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageContentFit; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+// Forward declaration of `OneKeyImageLoadingStrategy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageLoadingStrategy; }
+// Forward declaration of `OneKeyImageCacheType` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCacheType; }
+
+#include <string>
+#include <optional>
+#include "OneKeyImageVariant.hpp"
+#include "OneKeyImageContentFit.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include "OneKeyImageLoadingStrategy.hpp"
+#include <functional>
+#include "OneKeyImageCacheType.hpp"
+
+#include "OneKeyImage-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * The C++ part of HybridOneKeyImageSpec_cxx.swift.
+   *
+   * HybridOneKeyImageSpecSwift (C++) accesses HybridOneKeyImageSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridOneKeyImageSpec_cxx can directly inherit from the C++ class HybridOneKeyImageSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridOneKeyImageSpecSwift: public virtual HybridOneKeyImageSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridOneKeyImageSpecSwift(const OneKeyImage::HybridOneKeyImageSpec_cxx& swiftPart):
+      HybridObject(HybridOneKeyImageSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline OneKeyImage::HybridOneKeyImageSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridOneKeyImageSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<std::string> getSourceUri() noexcept override {
+      auto __result = _swiftPart.getSourceUri();
+      return __result;
+    }
+    inline void setSourceUri(const std::optional<std::string>& sourceUri) noexcept override {
+      _swiftPart.setSourceUri(sourceUri);
+    }
+    inline std::optional<std::string> getSourceHeadersJson() noexcept override {
+      auto __result = _swiftPart.getSourceHeadersJson();
+      return __result;
+    }
+    inline void setSourceHeadersJson(const std::optional<std::string>& sourceHeadersJson) noexcept override {
+      _swiftPart.setSourceHeadersJson(sourceHeadersJson);
+    }
+    inline std::optional<OneKeyImageVariant> getVariant() noexcept override {
+      auto __result = _swiftPart.getVariant();
+      return __result;
+    }
+    inline void setVariant(std::optional<OneKeyImageVariant> variant) noexcept override {
+      _swiftPart.setVariant(variant);
+    }
+    inline std::optional<OneKeyImageContentFit> getContentFit() noexcept override {
+      auto __result = _swiftPart.getContentFit();
+      return __result;
+    }
+    inline void setContentFit(std::optional<OneKeyImageContentFit> contentFit) noexcept override {
+      _swiftPart.setContentFit(contentFit);
+    }
+    inline std::optional<OneKeyImageCachePolicy> getCachePolicy() noexcept override {
+      auto __result = _swiftPart.getCachePolicy();
+      return __result;
+    }
+    inline void setCachePolicy(std::optional<OneKeyImageCachePolicy> cachePolicy) noexcept override {
+      _swiftPart.setCachePolicy(cachePolicy);
+    }
+    inline std::optional<bool> getAutoplay() noexcept override {
+      auto __result = _swiftPart.getAutoplay();
+      return __result;
+    }
+    inline void setAutoplay(std::optional<bool> autoplay) noexcept override {
+      _swiftPart.setAutoplay(autoplay);
+    }
+    inline std::optional<std::string> getRecyclingKey() noexcept override {
+      auto __result = _swiftPart.getRecyclingKey();
+      return __result;
+    }
+    inline void setRecyclingKey(const std::optional<std::string>& recyclingKey) noexcept override {
+      _swiftPart.setRecyclingKey(recyclingKey);
+    }
+    inline std::optional<bool> getOptimizeTos() noexcept override {
+      auto __result = _swiftPart.getOptimizeTos();
+      return __result;
+    }
+    inline void setOptimizeTos(std::optional<bool> optimizeTos) noexcept override {
+      _swiftPart.setOptimizeTos(optimizeTos);
+    }
+    inline std::optional<double> getOverscan() noexcept override {
+      auto __result = _swiftPart.getOverscan();
+      return __result;
+    }
+    inline void setOverscan(std::optional<double> overscan) noexcept override {
+      _swiftPart.setOverscan(overscan);
+    }
+    inline std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() noexcept override {
+      auto __result = _swiftPart.getLoadingStrategy();
+      return __result;
+    }
+    inline void setLoadingStrategy(std::optional<OneKeyImageLoadingStrategy> loadingStrategy) noexcept override {
+      _swiftPart.setLoadingStrategy(loadingStrategy);
+    }
+    inline std::optional<std::function<void()>> getOnLoadStart() noexcept override {
+      auto __result = _swiftPart.getOnLoadStart();
+      return __result;
+    }
+    inline void setOnLoadStart(const std::optional<std::function<void()>>& onLoadStart) noexcept override {
+      _swiftPart.setOnLoadStart(onLoadStart);
+    }
+    inline std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>> getOnLoad() noexcept override {
+      auto __result = _swiftPart.getOnLoad();
+      return __result;
+    }
+    inline void setOnLoad(const std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>& onLoad) noexcept override {
+      _swiftPart.setOnLoad(onLoad);
+    }
+    inline std::optional<std::function<void()>> getOnDisplay() noexcept override {
+      auto __result = _swiftPart.getOnDisplay();
+      return __result;
+    }
+    inline void setOnDisplay(const std::optional<std::function<void()>>& onDisplay) noexcept override {
+      _swiftPart.setOnDisplay(onDisplay);
+    }
+    inline std::optional<std::function<void(const std::string& /* message */)>> getOnError() noexcept override {
+      auto __result = _swiftPart.getOnError();
+      return __result;
+    }
+    inline void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) noexcept override {
+      _swiftPart.setOnError(onError);
+    }
+    inline std::optional<std::function<void()>> getOnLoadEnd() noexcept override {
+      auto __result = _swiftPart.getOnLoadEnd();
+      return __result;
+    }
+    inline void setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) noexcept override {
+      _swiftPart.setOnLoadEnd(onLoadEnd);
+    }
+
+  public:
+    // Methods
+    inline void reload() override {
+      auto __result = _swiftPart.reload();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void cancel() override {
+      auto __result = _swiftPart.cancel();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    OneKeyImage::HybridOneKeyImageSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage