react-native-nitro-cookies 1.1.0 → 1.2.1

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

@@ -55,16 +55,16 @@ namespace margelo::nitro::nitrocookies {
   std::vector<Cookie> JHybridNitroCookiesSpec::getSync(const std::string& url) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JCookie>>(jni::alias_ref<jni::JString> /* url */)>("getSync");
     auto __result = method(_javaPart, jni::make_jstring(url));
-    return [&]() {
-      size_t __size = __result->size();
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
       std::vector<Cookie> __vector;
       __vector.reserve(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        auto __element = __result->getElement(__i);
+        auto __element = __input->getElement(__i);
         __vector.push_back(__element->toCpp());
       }
       return __vector;
-    }();
+    }(__result);
   }
   bool JHybridNitroCookiesSpec::setSync(const std::string& url, const Cookie& cookie) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<JCookie> /* cookie */)>("setSync");
@@ -81,6 +81,25 @@ namespace margelo::nitro::nitrocookies {
     auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(name));
     return static_cast<bool>(__result);
   }
+  std::string JHybridNitroCookiesSpec::getCookieHeaderSync(const std::string& url) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* url */)>("getCookieHeaderSync");
+    auto __result = method(_javaPart, jni::make_jstring(url));
+    return __result->toStdString();
+  }
+  bool JHybridNitroCookiesSpec::setManySync(const std::string& url, const std::vector<Cookie>& cookies) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JArrayClass<JCookie>> /* cookies */)>("setManySync");
+    auto __result = method(_javaPart, jni::make_jstring(url), [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JCookie>> __array = jni::JArrayClass<JCookie>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JCookie::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(cookies));
+    return static_cast<bool>(__result);
+  }
   std::shared_ptr<Promise<bool>> JHybridNitroCookiesSpec::set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<JCookie> /* cookie */, jni::alias_ref<jni::JBoolean> /* useWebKit */)>("set");
     auto __result = method(_javaPart, jni::make_jstring(url), JCookie::fromCpp(cookie), useWebKit.has_value() ? jni::JBoolean::valueOf(useWebKit.value()) : nullptr);
@@ -97,6 +116,47 @@ namespace margelo::nitro::nitrocookies {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<bool>> JHybridNitroCookiesSpec::setMany(const std::string& url, const std::vector<Cookie>& cookies, std::optional<bool> useWebKit) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JArrayClass<JCookie>> /* cookies */, jni::alias_ref<jni::JBoolean> /* useWebKit */)>("setMany");
+    auto __result = method(_javaPart, jni::make_jstring(url), [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JCookie>> __array = jni::JArrayClass<JCookie>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JCookie::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(cookies), useWebKit.has_value() ? jni::JBoolean::valueOf(useWebKit.value()) : nullptr);
+    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<std::string>> JHybridNitroCookiesSpec::getCookieHeader(const std::string& url, std::optional<bool> useWebKit) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JBoolean> /* useWebKit */)>("getCookieHeader");
+    auto __result = method(_javaPart, jni::make_jstring(url), useWebKit.has_value() ? jni::JBoolean::valueOf(useWebKit.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __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<std::vector<Cookie>>> JHybridNitroCookiesSpec::get(const std::string& url, std::optional<bool> useWebKit) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JBoolean> /* useWebKit */)>("get");
     auto __result = method(_javaPart, jni::make_jstring(url), useWebKit.has_value() ? jni::JBoolean::valueOf(useWebKit.value()) : nullptr);
@@ -104,16 +164,16 @@ namespace margelo::nitro::nitrocookies {
       auto __promise = Promise<std::vector<Cookie>>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
         auto __result = jni::static_ref_cast<jni::JArrayClass<JCookie>>(__boxedResult);
-        __promise->resolve([&]() {
-          size_t __size = __result->size();
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<Cookie> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = __result->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }());
+        }(__result));
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
         jni::JniException __jniError(__throwable);
@@ -161,16 +221,16 @@ namespace margelo::nitro::nitrocookies {
       auto __promise = Promise<std::vector<Cookie>>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
         auto __result = jni::static_ref_cast<jni::JArrayClass<JCookie>>(__boxedResult);
-        __promise->resolve([&]() {
-          size_t __size = __result->size();
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<Cookie> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = __result->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }());
+        }(__result));
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
         jni::JniException __jniError(__throwable);
@@ -186,16 +246,16 @@ namespace margelo::nitro::nitrocookies {
       auto __promise = Promise<std::vector<Cookie>>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
         auto __result = jni::static_ref_cast<jni::JArrayClass<JCookie>>(__boxedResult);
-        __promise->resolve([&]() {
-          size_t __size = __result->size();
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<Cookie> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = __result->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }());
+        }(__result));
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
         jni::JniException __jniError(__throwable);

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

@@ -21,11 +21,11 @@ namespace margelo::nitro::nitrocookies {
   class JHybridNitroCookiesSpec: public virtual HybridNitroCookiesSpec, public virtual JHybridObject {
   public:
     struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/HybridNitroCookiesSpec;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/HybridNitroCookiesSpec;";
       std::shared_ptr<JHybridNitroCookiesSpec> getJHybridNitroCookiesSpec();
     };
     struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/HybridNitroCookiesSpec$CxxPart;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/HybridNitroCookiesSpec$CxxPart;";
       static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
       static void registerNatives();
       using HybridBase::HybridBase;
@@ -58,7 +58,11 @@ namespace margelo::nitro::nitrocookies {
     bool setSync(const std::string& url, const Cookie& cookie) override;
     bool setFromResponseSync(const std::string& url, const std::string& value) override;
     bool clearByNameSync(const std::string& url, const std::string& name) override;
+    std::string getCookieHeaderSync(const std::string& url) override;
+    bool setManySync(const std::string& url, const std::vector<Cookie>& cookies) override;
     std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) override;
+    std::shared_ptr<Promise<bool>> setMany(const std::string& url, const std::vector<Cookie>& cookies, std::optional<bool> useWebKit) override;
+    std::shared_ptr<Promise<std::string>> getCookieHeader(const std::string& url, std::optional<bool> useWebKit) override;
     std::shared_ptr<Promise<std::vector<Cookie>>> get(const std::string& url, std::optional<bool> useWebKit) override;
     std::shared_ptr<Promise<bool>> clearAll(std::optional<bool> useWebKit) override;
     std::shared_ptr<Promise<bool>> setFromResponse(const std::string& url, const std::string& value) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocookies/Cookie.kt

@@ -9,6 +9,7 @@ package com.margelo.nitro.nitrocookies
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -44,6 +45,32 @@ data class Cookie(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Cookie) return false
+    return Objects.deepEquals(this.name, other.name)
+      && Objects.deepEquals(this.value, other.value)
+      && Objects.deepEquals(this.path, other.path)
+      && Objects.deepEquals(this.domain, other.domain)
+      && Objects.deepEquals(this.version, other.version)
+      && Objects.deepEquals(this.expires, other.expires)
+      && Objects.deepEquals(this.secure, other.secure)
+      && Objects.deepEquals(this.httpOnly, other.httpOnly)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      name,
+      value,
+      path,
+      domain,
+      version,
+      expires,
+      secure,
+      httpOnly
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocookies/HybridNitroCookiesSpec.kt

@@ -45,10 +45,26 @@ abstract class HybridNitroCookiesSpec: HybridObject() {
   @Keep
   abstract fun clearByNameSync(url: String, name: String): Boolean
   
+  @DoNotStrip
+  @Keep
+  abstract fun getCookieHeaderSync(url: String): String
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setManySync(url: String, cookies: Array<Cookie>): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun set(url: String, cookie: Cookie, useWebKit: Boolean?): Promise<Boolean>
   
+  @DoNotStrip
+  @Keep
+  abstract fun setMany(url: String, cookies: Array<Cookie>, useWebKit: Boolean?): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCookieHeader(url: String, useWebKit: Boolean?): Promise<String>
+  
   @DoNotStrip
   @Keep
   abstract fun get(url: String, useWebKit: Boolean?): Promise<Array<Cookie>>

package/nitrogen/generated/android/nitrocookiesOnLoad.cpp

@@ -27,9 +27,9 @@ int initialize(JavaVM* vm) {
 }
 
 struct JHybridNitroCookiesSpecImpl: public jni::JavaClass<JHybridNitroCookiesSpecImpl, JHybridNitroCookiesSpec::JavaPart> {
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/NitroCookies;";
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocookies/NitroCookies;";
   static std::shared_ptr<JHybridNitroCookiesSpec> create() {
-    static auto constructorFn = javaClassStatic()->getConstructor<JHybridNitroCookiesSpecImpl::javaobject()>();
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNitroCookiesSpecImpl::javaobject()>();
     jni::local_ref<JHybridNitroCookiesSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
     return javaPart->getJHybridNitroCookiesSpec();
   }

package/nitrogen/generated/ios/NitroCookies+autolinking.rb

@@ -56,5 +56,7 @@ def add_nitrogen_files(spec)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
   })
 end

package/nitrogen/generated/ios/NitroCookies-Swift-Cxx-Bridge.cpp

@@ -30,6 +30,14 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroCookies::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::vector<Cookie>& /* result */)>
   Func_void_std__vector_Cookie_ create_Func_void_std__vector_Cookie_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroCookies::Func_void_std__vector_Cookie_::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/NitroCookies-Swift-Cxx-Bridge.hpp

@@ -133,6 +133,40 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<std::vector<Cookie>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::vector<Cookie>>>`.
@@ -231,6 +265,15 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
     return Result<bool>::withError(error);
   }
   
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
   using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
   inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
@@ -240,6 +283,15 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
     return Result<std::shared_ptr<Promise<bool>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<Cookie>>>>
   using Result_std__shared_ptr_Promise_std__vector_Cookie____ = Result<std::shared_ptr<Promise<std::vector<Cookie>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_Cookie____ create_Result_std__shared_ptr_Promise_std__vector_Cookie____(const std::shared_ptr<Promise<std::vector<Cookie>>>& value) noexcept {

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

@@ -103,6 +103,22 @@ namespace margelo::nitro::nitrocookies {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::string getCookieHeaderSync(const std::string& url) override {
+      auto __result = _swiftPart.getCookieHeaderSync(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setManySync(const std::string& url, const std::vector<Cookie>& cookies) override {
+      auto __result = _swiftPart.setManySync(url, cookies);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) override {
       auto __result = _swiftPart.set(url, std::forward<decltype(cookie)>(cookie), useWebKit);
       if (__result.hasError()) [[unlikely]] {
@@ -111,6 +127,22 @@ namespace margelo::nitro::nitrocookies {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<bool>> setMany(const std::string& url, const std::vector<Cookie>& cookies, std::optional<bool> useWebKit) override {
+      auto __result = _swiftPart.setMany(url, cookies, useWebKit);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> getCookieHeader(const std::string& url, std::optional<bool> useWebKit) override {
+      auto __result = _swiftPart.getCookieHeader(url, useWebKit);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<Cookie>>> get(const std::string& url, std::optional<bool> useWebKit) override {
       auto __result = _swiftPart.get(url, useWebKit);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_std__string.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_std__string.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__string {
+  public typealias bridge = margelo.nitro.nitrocookies.bridge.swift
+
+  private let closure: (_ value: String) -> Void
+
+  public init(_ closure: @escaping (_ value: String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: std.string) -> Void {
+    self.closure(String(value))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
+    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroCookiesSpec.swift

@@ -17,7 +17,11 @@ public protocol HybridNitroCookiesSpec_protocol: HybridObject {
   func setSync(url: String, cookie: Cookie) throws -> Bool
   func setFromResponseSync(url: String, value: String) throws -> Bool
   func clearByNameSync(url: String, name: String) throws -> Bool
+  func getCookieHeaderSync(url: String) throws -> String
+  func setManySync(url: String, cookies: [Cookie]) throws -> Bool
   func set(url: String, cookie: Cookie, useWebKit: Bool?) throws -> Promise<Bool>
+  func setMany(url: String, cookies: [Cookie], useWebKit: Bool?) throws -> Promise<Bool>
+  func getCookieHeader(url: String, useWebKit: Bool?) throws -> Promise<String>
   func get(url: String, useWebKit: Bool?) throws -> Promise<[Cookie]>
   func clearAll(useWebKit: Bool?) throws -> Promise<Bool>
   func setFromResponse(url: String, value: String) throws -> Promise<Bool>

package/nitrogen/generated/ios/swift/HybridNitroCookiesSpec_cxx.swift

@@ -178,6 +178,30 @@ open class HybridNitroCookiesSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getCookieHeaderSync(url: std.string) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getCookieHeaderSync(url: String(url))
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setManySync(url: std.string, cookies: bridge.std__vector_Cookie_) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setManySync(url: String(url), cookies: cookies.map({ __item in __item }))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func set(url: std.string, cookie: Cookie, useWebKit: bridge.std__optional_bool_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
@@ -204,6 +228,58 @@ open class HybridNitroCookiesSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setMany(url: std.string, cookies: bridge.std__vector_Cookie_, useWebKit: bridge.std__optional_bool_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.setMany(url: String(url), cookies: cookies.map({ __item in __item }), useWebKit: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(useWebKit) {
+          let __unwrapped = bridge.get_std__optional_bool_(useWebKit)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCookieHeader(url: std.string, useWebKit: bridge.std__optional_bool_) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.getCookieHeader(url: String(url), useWebKit: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(useWebKit) {
+          let __unwrapped = bridge.get_std__optional_bool_(useWebKit)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func get(url: std.string, useWebKit: bridge.std__optional_bool_) -> bridge.Result_std__shared_ptr_Promise_std__vector_Cookie____ {
     do {

package/nitrogen/generated/shared/c++/HybridNitroCookiesSpec.cpp

@@ -18,7 +18,11 @@ namespace margelo::nitro::nitrocookies {
       prototype.registerHybridMethod("setSync", &HybridNitroCookiesSpec::setSync);
       prototype.registerHybridMethod("setFromResponseSync", &HybridNitroCookiesSpec::setFromResponseSync);
       prototype.registerHybridMethod("clearByNameSync", &HybridNitroCookiesSpec::clearByNameSync);
+      prototype.registerHybridMethod("getCookieHeaderSync", &HybridNitroCookiesSpec::getCookieHeaderSync);
+      prototype.registerHybridMethod("setManySync", &HybridNitroCookiesSpec::setManySync);
       prototype.registerHybridMethod("set", &HybridNitroCookiesSpec::set);
+      prototype.registerHybridMethod("setMany", &HybridNitroCookiesSpec::setMany);
+      prototype.registerHybridMethod("getCookieHeader", &HybridNitroCookiesSpec::getCookieHeader);
       prototype.registerHybridMethod("get", &HybridNitroCookiesSpec::get);
       prototype.registerHybridMethod("clearAll", &HybridNitroCookiesSpec::clearAll);
       prototype.registerHybridMethod("setFromResponse", &HybridNitroCookiesSpec::setFromResponse);

package/nitrogen/generated/shared/c++/HybridNitroCookiesSpec.hpp

@@ -57,7 +57,11 @@ namespace margelo::nitro::nitrocookies {
       virtual bool setSync(const std::string& url, const Cookie& cookie) = 0;
       virtual bool setFromResponseSync(const std::string& url, const std::string& value) = 0;
       virtual bool clearByNameSync(const std::string& url, const std::string& name) = 0;
+      virtual std::string getCookieHeaderSync(const std::string& url) = 0;
+      virtual bool setManySync(const std::string& url, const std::vector<Cookie>& cookies) = 0;
       virtual std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) = 0;
+      virtual std::shared_ptr<Promise<bool>> setMany(const std::string& url, const std::vector<Cookie>& cookies, std::optional<bool> useWebKit) = 0;
+      virtual std::shared_ptr<Promise<std::string>> getCookieHeader(const std::string& url, std::optional<bool> useWebKit) = 0;
       virtual std::shared_ptr<Promise<std::vector<Cookie>>> get(const std::string& url, std::optional<bool> useWebKit) = 0;
       virtual std::shared_ptr<Promise<bool>> clearAll(std::optional<bool> useWebKit) = 0;
       virtual std::shared_ptr<Promise<bool>> setFromResponse(const std::string& url, const std::string& value) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-cookies",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Fetch, Get Cookies 🍪 at the Speed of Nitro",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -72,16 +72,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native/babel-preset": "0.84.0",
+    "@react-native/babel-preset": "0.85.3",
+    "@react-native/jest-preset": "0.85.3",
     "@types/jest": "30.0.0",
-    "@types/react": "19.2.14",
+    "@types/react": "19.2.17",
     "del-cli": "6.0.0",
     "jest": "30.2.0",
-    "nitrogen": "0.35.0",
-    "react": "19.2.3",
-    "react-native": "0.84.0",
+    "nitrogen": "0.35.9",
+    "react": "19.2.7",
+    "react-native": "0.85.3",
     "react-native-builder-bob": "0.40.18",
-    "react-native-nitro-modules": "0.35.0",
+    "react-native-nitro-modules": "0.35.9",
     "typescript": "5.9.3"
   },
   "peerDependencies": {