@onekeyfe/react-native-image 3.0.98

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

@@ -0,0 +1,55 @@
+import { type ReactNode } from 'react';
+import { type ImageURISource, type ViewProps } from 'react-native';
+import { type NitroViewWrappedCallback } from 'react-native-nitro-modules';
+import type { OneKeyImageMethods, OneKeyImageNativeProps } from './OneKeyImage.nitro';
+import { OneKeyImageCachePolicy, OneKeyImageContentFit, OneKeyImageLoadingStrategy, OneKeyImageVariant } from './OneKeyImage.nitro';
+export { OneKeyImageCachePolicy, OneKeyImageContentFit, OneKeyImageLoadingStrategy, OneKeyImageVariant, };
+export type { OneKeyImageMethods, OneKeyImageNativeProps, OneKeyImagePreloadSource, } from './OneKeyImage.nitro';
+export declare enum OneKeyImageCacheType {
+    NONE = "none",
+    MEMORY = "memory",
+    DISK = "disk"
+}
+type MaybeWrappedCallback<T extends (...args: any[]) => void> = T | NitroViewWrappedCallback<T>;
+export interface OneKeyImageSource extends ImageURISource {
+    cachePolicy?: OneKeyImageCachePolicy;
+}
+export interface OneKeyImagePreloadInput extends OneKeyImageSource {
+    resizeWidth?: number;
+    resizeHeight?: number;
+    pixelRatio?: number;
+    overscan?: number;
+    optimizeTos?: boolean;
+}
+export interface OneKeyImageLoadEvent {
+    source: {
+        url: string;
+        width: number;
+        height: number;
+    };
+    cacheType: OneKeyImageCacheType;
+}
+export interface OneKeyImageErrorEvent {
+    error: string;
+}
+export interface OneKeyImageProps extends Omit<OneKeyImageNativeProps, 'sourceUri' | 'sourceHeadersJson' | 'onLoadStart' | 'onLoad' | 'onDisplay' | 'onError' | 'onLoadEnd'>, ViewProps {
+    source?: OneKeyImageSource | number;
+    /** Content shown while a non-null source is loading. */
+    placeholder?: ReactNode;
+    /** Content shown when source is unavailable or fails to load. */
+    fallback?: ReactNode;
+    hybridRef?: MaybeWrappedCallback<(ref: OneKeyImageMethods) => void>;
+    onLoadStart?: MaybeWrappedCallback<() => void>;
+    onLoad?: MaybeWrappedCallback<(event: OneKeyImageLoadEvent) => void>;
+    onDisplay?: MaybeWrappedCallback<() => void>;
+    onError?: MaybeWrappedCallback<(event: OneKeyImageErrorEvent) => void>;
+    onLoadEnd?: MaybeWrappedCallback<() => void>;
+}
+export declare function OneKeyImage({ source, placeholder, fallback, variant, contentFit, cachePolicy, autoplay, recyclingKey, optimizeTos, overscan, loadingStrategy, hybridRef, onLoadStart, onLoad, onDisplay, onError, onLoadEnd, style, ...viewProps }: OneKeyImageProps): import("react/jsx-runtime").JSX.Element;
+export declare const OneKeyImageCache: {
+    preload(sources: OneKeyImagePreloadInput[]): Promise<boolean>;
+    clearMemory: () => Promise<void>;
+    clearDisk: () => Promise<void>;
+    clearAll: () => Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/nitro.json

@@ -0,0 +1,31 @@
+{
+  "cxxNamespace": ["onekeyimage"],
+  "ios": { "iosModuleName": "OneKeyImage" },
+  "android": {
+    "androidNamespace": ["onekeyimage"],
+    "androidCxxLibName": "onekeyimage"
+  },
+  "autolinking": {
+    "OneKeyImage": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridOneKeyImage"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridOneKeyImage"
+      }
+    },
+    "OneKeyImageCache": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridOneKeyImageCache"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridOneKeyImageCache"
+      }
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_double_double_OneKeyImageCacheType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "OneKeyImageCacheType.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JOneKeyImageCacheType.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(width: Double, height: Double, cacheType: OneKeyImageCacheType) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double_OneKeyImageCacheType: public jni::JavaClass<JFunc_void_double_double_OneKeyImageCacheType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_double_double_OneKeyImageCacheType;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double_OneKeyImageCacheType` instance holds through JNI.
+     */
+    void invoke(double width, double height, OneKeyImageCacheType cacheType) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* width */, double /* height */, jni::alias_ref<JOneKeyImageCacheType> /* cacheType */)>("invoke");
+      method(self(), width, height, JOneKeyImageCacheType::fromCpp(cacheType));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double_OneKeyImageCacheType that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_OneKeyImageCacheType_cxx final: public jni::HybridClass<JFunc_void_double_double_OneKeyImageCacheType_cxx, JFunc_void_double_double_OneKeyImageCacheType> {
+  public:
+    static jni::local_ref<JFunc_void_double_double_OneKeyImageCacheType::javaobject> fromCpp(const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& func) {
+      return JFunc_void_double_double_OneKeyImageCacheType_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_OneKeyImageCacheType_cxx` instance holds.
+     */
+    void invoke_cxx(double width, double height, jni::alias_ref<JOneKeyImageCacheType> cacheType) {
+      _func(width, height, cacheType->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_double_double_OneKeyImageCacheType_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_OneKeyImageCacheType_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_OneKeyImageCacheType_cxx(const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(message: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& message) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("invoke");
+      method(self(), jni::make_jstring(message));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* message */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> message) {
+      _func(message->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* message */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* message */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* message */)> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,130 @@
+///
+/// JHybridOneKeyImageCacheSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyImageCacheSpec.hpp"
+
+// 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 <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "OneKeyImagePreloadSource.hpp"
+#include <vector>
+#include "JOneKeyImagePreloadSource.hpp"
+#include <string>
+#include <optional>
+#include "OneKeyImageCachePolicy.hpp"
+#include "JOneKeyImageCachePolicy.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  std::shared_ptr<JHybridOneKeyImageCacheSpec> JHybridOneKeyImageCacheSpec::JavaPart::getJHybridOneKeyImageCacheSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridOneKeyImageCacheSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridOneKeyImageCacheSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridOneKeyImageCacheSpec::CxxPart::jhybriddata> JHybridOneKeyImageCacheSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridOneKeyImageCacheSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridOneKeyImageCacheSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridOneKeyImageCacheSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridOneKeyImageCacheSpec>(castJavaPart);
+  }
+
+  void JHybridOneKeyImageCacheSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridOneKeyImageCacheSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<bool>> JHybridOneKeyImageCacheSpec::preload(const std::vector<OneKeyImagePreloadSource>& sources) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JOneKeyImagePreloadSource>> /* sources */)>("preload");
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JOneKeyImagePreloadSource>> __array = jni::JArrayClass<JOneKeyImagePreloadSource>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JOneKeyImagePreloadSource::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(sources));
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearMemory() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearMemory");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearDisk() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearDisk");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearAll() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearAll");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,66 @@
+///
+/// HybridOneKeyImageCacheSpec.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 "HybridOneKeyImageCacheSpec.hpp"
+
+
+
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  class JHybridOneKeyImageCacheSpec: public virtual HybridOneKeyImageCacheSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageCacheSpec;";
+      std::shared_ptr<JHybridOneKeyImageCacheSpec> getJHybridOneKeyImageCacheSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageCacheSpec$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 JHybridOneKeyImageCacheSpec(const jni::local_ref<JHybridOneKeyImageCacheSpec::JavaPart>& javaPart):
+      HybridObject(HybridOneKeyImageCacheSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridOneKeyImageCacheSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridOneKeyImageCacheSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<bool>> preload(const std::vector<OneKeyImagePreloadSource>& sources) override;
+    std::shared_ptr<Promise<void>> clearMemory() override;
+    std::shared_ptr<Promise<void>> clearDisk() override;
+    std::shared_ptr<Promise<void>> clearAll() override;
+
+  private:
+    jni::global_ref<JHybridOneKeyImageCacheSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage