react-native-nitro-cookies 1.0.4 → 1.2.0

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.0.4",
+  "version": "1.2.0",
   "description": "Fetch, Get Cookies 🍪 at the Speed of Nitro",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -72,22 +72,23 @@
     "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.33.9",
-    "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.33.9",
+    "react-native-nitro-modules": "0.35.9",
     "typescript": "5.9.3"
   },
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "~0.33.9"
+    "react-native-nitro-modules": ">=0.35.0 <1.0.0"
   },
   "prettier": {
     "quoteProps": "consistent",

package/src/NitroCookies.nitro.ts

@@ -75,6 +75,33 @@ export interface NitroCookies extends HybridObject<{
    */
   clearByNameSync(url: string, name: string): boolean;
 
+  /**
+   * Get the `Cookie` request-header string for a URL synchronously
+   *
+   * Returns the value you would put in an HTTP `Cookie` request header
+   * (e.g. "name1=value1; name2=value2"), built from every cookie that
+   * matches the URL. Use this to attach cookies to a manual `fetch`/
+   * `XMLHttpRequest`. Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @returns The Cookie header string, or "" when no cookies match
+   * @throws Error if URL is invalid
+   */
+  getCookieHeaderSync(url: string): string;
+
+  /**
+   * Set multiple cookies for a URL synchronously
+   *
+   * Applies the same domain validation as `setSync` to every cookie.
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   *
+   * @param url - The URL for which to set the cookies (must include protocol)
+   * @param cookies - The cookie objects to store
+   * @returns true on success
+   * @throws Error if URL is invalid or any cookie's domain mismatches
+   */
+  setManySync(url: string, cookies: Cookie[]): boolean;
+
   // ========================================
   // ASYNCHRONOUS METHODS
   // ========================================
@@ -89,6 +116,35 @@ export interface NitroCookies extends HybridObject<{
    */
   set(url: string, cookie: Cookie, useWebKit?: boolean): Promise<boolean>;
 
+  /**
+   * Set multiple cookies for a URL
+   *
+   * Applies the same domain validation as `set` to every cookie.
+   *
+   * @param url - The URL for which to set the cookies (must include protocol)
+   * @param cookies - The cookie objects to store
+   * @param useWebKit - (iOS only) If true, use WKHTTPCookieStore instead of NSHTTPCookieStorage (requires iOS 11+)
+   * @returns Promise that resolves to true on success
+   */
+  setMany(
+    url: string,
+    cookies: Cookie[],
+    useWebKit?: boolean
+  ): Promise<boolean>;
+
+  /**
+   * Get the `Cookie` request-header string for a URL
+   *
+   * Returns the value you would put in an HTTP `Cookie` request header
+   * (e.g. "name1=value1; name2=value2"), built from every cookie that
+   * matches the URL.
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @param useWebKit - (iOS only) If true, read from WKHTTPCookieStore instead of NSHTTPCookieStorage
+   * @returns Promise that resolves to the Cookie header string, or "" when no cookies match
+   */
+  getCookieHeader(url: string, useWebKit?: boolean): Promise<string>;
+
   /**
    * Get all cookies matching a specific URL's domain
    *

package/src/index.tsx

@@ -123,6 +123,53 @@ export const NitroCookies = {
     return NitroCookiesHybridObject.clearByNameSync(url, name);
   },
 
+  /**
+   * Get the `Cookie` request-header string for a URL synchronously.
+   *
+   * Returns the value you would put in an HTTP `Cookie` request header
+   * (e.g. `"name1=value1; name2=value2"`), built from every cookie that
+   * matches the URL. Handy for attaching cookies to a manual `fetch` or
+   * `XMLHttpRequest`. Returns an empty string when no cookies match.
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @returns The Cookie header string, or "" when no cookies match
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   *
+   * @example
+   * ```typescript
+   * const header = NitroCookies.getCookieHeaderSync('https://example.com');
+   * await fetch('https://example.com/api', { headers: { Cookie: header } });
+   * ```
+   */
+  getCookieHeaderSync(url: string): string {
+    return NitroCookiesHybridObject.getCookieHeaderSync(url);
+  },
+
+  /**
+   * Set multiple cookies for a URL synchronously.
+   *
+   * Applies the same domain validation as `setSync` to every cookie. If any
+   * cookie's domain doesn't match the URL host, the whole call throws and no
+   * cookies are written.
+   *
+   * @param url - The URL for which to set the cookies (must include protocol)
+   * @param cookies - The cookie objects to store
+   * @returns true on success
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   * @throws {Error} DOMAIN_MISMATCH - A cookie's domain doesn't match URL host
+   *
+   * @example
+   * ```typescript
+   * NitroCookies.setManySync('https://example.com', [
+   *   { name: 'session', value: 'abc123' },
+   *   { name: 'theme', value: 'dark' },
+   * ]);
+   * ```
+   */
+  setManySync(url: string, cookies: Cookie[]): boolean {
+    return NitroCookiesHybridObject.setManySync(url, cookies);
+  },
+
   // ========================================
   // ASYNCHRONOUS METHODS
   // ========================================
@@ -168,6 +215,63 @@ export const NitroCookies = {
     return NitroCookiesHybridObject.set(url, cookie, useWebKit ?? false);
   },
 
+  /**
+   * Set multiple cookies for a URL.
+   *
+   * Applies the same domain validation as `set` to every cookie. If any
+   * cookie's domain doesn't match the URL host, the whole call rejects and no
+   * cookies are written.
+   *
+   * @param url - The URL for which to set the cookies. Must include protocol.
+   * @param cookies - The cookie objects to store
+   * @param useWebKit - (iOS only) If true, use WKHTTPCookieStore instead of NSHTTPCookieStorage. Requires iOS 11+.
+   *
+   * @returns Promise that resolves to true on success
+   *
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   * @throws {Error} DOMAIN_MISMATCH - A cookie's domain doesn't match URL host
+   * @throws {Error} WEBKIT_UNAVAILABLE - useWebKit=true on iOS < 11
+   *
+   * @example
+   * ```typescript
+   * await NitroCookies.setMany('https://example.com', [
+   *   { name: 'session', value: 'abc123', secure: true },
+   *   { name: 'theme', value: 'dark' },
+   * ]);
+   * ```
+   */
+  async setMany(
+    url: string,
+    cookies: Cookie[],
+    useWebKit?: boolean
+  ): Promise<boolean> {
+    return NitroCookiesHybridObject.setMany(url, cookies, useWebKit ?? false);
+  },
+
+  /**
+   * Get the `Cookie` request-header string for a URL.
+   *
+   * Returns the value you would put in an HTTP `Cookie` request header
+   * (e.g. `"name1=value1; name2=value2"`), built from every cookie that
+   * matches the URL. Returns an empty string when no cookies match.
+   *
+   * @param url - The URL to match cookies against. Must include protocol.
+   * @param useWebKit - (iOS only) If true, read from WKHTTPCookieStore instead of NSHTTPCookieStorage
+   *
+   * @returns Promise that resolves to the Cookie header string, or "" when no cookies match
+   *
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   *
+   * @example
+   * ```typescript
+   * const header = await NitroCookies.getCookieHeader('https://example.com');
+   * await fetch('https://example.com/api', { headers: { Cookie: header } });
+   * ```
+   */
+  async getCookieHeader(url: string, useWebKit?: boolean): Promise<string> {
+    return NitroCookiesHybridObject.getCookieHeader(url, useWebKit ?? false);
+  },
+
   /**
    * Get all cookies matching a specific URL's domain.
    *