react-native-nitro-fetch 1.2.1 → 1.3.1

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

@@ -12,6 +12,8 @@
 
 #include "JNitroHeader.hpp"
 #include "NitroHeader.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
 #include <optional>
 #include <string>
 #include <vector>
@@ -49,8 +51,8 @@ namespace margelo::nitro::nitrofetch {
       jni::local_ref<jni::JArrayClass<JNitroHeader>> headers = this->getFieldValue(fieldHeaders);
       static const auto fieldBodyString = clazz->getField<jni::JString>("bodyString");
       jni::local_ref<jni::JString> bodyString = this->getFieldValue(fieldBodyString);
-      static const auto fieldBodyBytes = clazz->getField<jni::JString>("bodyBytes");
-      jni::local_ref<jni::JString> bodyBytes = this->getFieldValue(fieldBodyBytes);
+      static const auto fieldBodyBytes = clazz->getField<JArrayBuffer::javaobject>("bodyBytes");
+      jni::local_ref<JArrayBuffer::javaobject> bodyBytes = this->getFieldValue(fieldBodyBytes);
       return NitroResponse(
         url->toStdString(),
         status,
@@ -68,7 +70,7 @@ namespace margelo::nitro::nitrofetch {
           return __vector;
         }(),
         bodyString != nullptr ? std::make_optional(bodyString->toStdString()) : std::nullopt,
-        bodyBytes != nullptr ? std::make_optional(bodyBytes->toStdString()) : std::nullopt
+        bodyBytes != nullptr ? std::make_optional(bodyBytes->cthis()->getArrayBuffer()) : std::nullopt
       );
     }
 
@@ -78,7 +80,7 @@ namespace margelo::nitro::nitrofetch {
      */
     [[maybe_unused]]
     static jni::local_ref<JNitroResponse::javaobject> fromCpp(const NitroResponse& value) {
-      using JSignature = JNitroResponse(jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jboolean, jboolean, jni::alias_ref<jni::JArrayClass<JNitroHeader>>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      using JSignature = JNitroResponse(jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jboolean, jboolean, jni::alias_ref<jni::JArrayClass<JNitroHeader>>, jni::alias_ref<jni::JString>, jni::alias_ref<JArrayBuffer::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -99,7 +101,7 @@ namespace margelo::nitro::nitrofetch {
           return __array;
         }(),
         value.bodyString.has_value() ? jni::make_jstring(value.bodyString.value()) : nullptr,
-        value.bodyBytes.has_value() ? jni::make_jstring(value.bodyBytes.value()) : nullptr
+        value.bodyBytes.has_value() ? JArrayBuffer::wrap(value.bodyBytes.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrofetch/NitroRequest.kt

@@ -43,6 +43,9 @@ data class NitroRequest(
   val followRedirects: Boolean?,
   @DoNotStrip
   @Keep
+  val prefetchCacheTtlMs: Double?,
+  @DoNotStrip
+  @Keep
   val requestId: String?
 ) {
   /* primary constructor */
@@ -55,8 +58,8 @@ data class NitroRequest(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(url: String, method: NitroRequestMethod?, headers: Array<NitroHeader>?, bodyString: String?, bodyBytes: String?, bodyFormData: Array<NitroFormDataPart>?, timeoutMs: Double?, followRedirects: Boolean?, requestId: String?): NitroRequest {
-      return NitroRequest(url, method, headers, bodyString, bodyBytes, bodyFormData, timeoutMs, followRedirects, requestId)
+    private fun fromCpp(url: String, method: NitroRequestMethod?, headers: Array<NitroHeader>?, bodyString: String?, bodyBytes: String?, bodyFormData: Array<NitroFormDataPart>?, timeoutMs: Double?, followRedirects: Boolean?, prefetchCacheTtlMs: Double?, requestId: String?): NitroRequest {
+      return NitroRequest(url, method, headers, bodyString, bodyBytes, bodyFormData, timeoutMs, followRedirects, prefetchCacheTtlMs, requestId)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrofetch/NitroResponse.kt

@@ -9,7 +9,7 @@ package com.margelo.nitro.nitrofetch
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
-
+import com.margelo.nitro.core.ArrayBuffer
 
 /**
  * Represents the JavaScript object/struct "NitroResponse".
@@ -40,7 +40,7 @@ data class NitroResponse(
   val bodyString: String?,
   @DoNotStrip
   @Keep
-  val bodyBytes: String?
+  val bodyBytes: ArrayBuffer?
 ) {
   /* primary constructor */
 
@@ -52,7 +52,7 @@ data class NitroResponse(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(url: String, status: Double, statusText: String, ok: Boolean, redirected: Boolean, headers: Array<NitroHeader>, bodyString: String?, bodyBytes: String?): NitroResponse {
+    private fun fromCpp(url: String, status: Double, statusText: String, ok: Boolean, redirected: Boolean, headers: Array<NitroHeader>, bodyString: String?, bodyBytes: ArrayBuffer?): NitroResponse {
       return NitroResponse(url, status, statusText, ok, redirected, headers, bodyString, bodyBytes)
     }
   }

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

@@ -393,6 +393,21 @@ namespace margelo::nitro::nitrofetch::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<std::shared_ptr<ArrayBuffer>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<ArrayBuffer>>`.
+   */
+  using std__optional_std__shared_ptr_ArrayBuffer__ = std::optional<std::shared_ptr<ArrayBuffer>>;
+  inline std::optional<std::shared_ptr<ArrayBuffer>> create_std__optional_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
+    return std::optional<std::shared_ptr<ArrayBuffer>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<ArrayBuffer> get_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<NitroResponse>>
   /**
    * Specialized version of `std::shared_ptr<Promise<NitroResponse>>`.

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

@@ -16,6 +16,8 @@ namespace NitroFetch { class HybridNitroFetchClientSpec_cxx; }
 namespace margelo::nitro::nitrofetch { struct NitroResponse; }
 // Forward declaration of `NitroHeader` to properly resolve imports.
 namespace margelo::nitro::nitrofetch { struct NitroHeader; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `NitroRequest` to properly resolve imports.
 namespace margelo::nitro::nitrofetch { struct NitroRequest; }
 // Forward declaration of `NitroRequestMethod` to properly resolve imports.
@@ -29,6 +31,8 @@ namespace margelo::nitro::nitrofetch { struct NitroFormDataPart; }
 #include "NitroHeader.hpp"
 #include <vector>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include "NitroRequest.hpp"
 #include "NitroRequestMethod.hpp"
 #include "NitroFormDataPart.hpp"

package/nitrogen/generated/ios/swift/NitroRequest.swift

@@ -18,7 +18,7 @@ public extension NitroRequest {
   /**
    * Create a new instance of `NitroRequest`.
    */
-  init(url: String, method: NitroRequestMethod?, headers: [NitroHeader]?, bodyString: String?, bodyBytes: String?, bodyFormData: [NitroFormDataPart]?, timeoutMs: Double?, followRedirects: Bool?, requestId: String?) {
+  init(url: String, method: NitroRequestMethod?, headers: [NitroHeader]?, bodyString: String?, bodyBytes: String?, bodyFormData: [NitroFormDataPart]?, timeoutMs: Double?, followRedirects: Bool?, prefetchCacheTtlMs: Double?, requestId: String?) {
     self.init(std.string(url), { () -> bridge.std__optional_NitroRequestMethod_ in
       if let __unwrappedValue = method {
         return bridge.create_std__optional_NitroRequestMethod_(__unwrappedValue)
@@ -73,6 +73,12 @@ public extension NitroRequest {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = prefetchCacheTtlMs {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }(), { () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = requestId {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
@@ -182,6 +188,18 @@ public extension NitroRequest {
     }()
   }
   
+  @inline(__always)
+  var prefetchCacheTtlMs: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__prefetchCacheTtlMs) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__prefetchCacheTtlMs)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
   @inline(__always)
   var requestId: String? {
     return { () -> String? in

package/nitrogen/generated/ios/swift/NitroResponse.swift

@@ -18,7 +18,7 @@ public extension NitroResponse {
   /**
    * Create a new instance of `NitroResponse`.
    */
-  init(url: String, status: Double, statusText: String, ok: Bool, redirected: Bool, headers: [NitroHeader], bodyString: String?, bodyBytes: String?) {
+  init(url: String, status: Double, statusText: String, ok: Bool, redirected: Bool, headers: [NitroHeader], bodyString: String?, bodyBytes: ArrayBuffer?) {
     self.init(std.string(url), status, std.string(statusText), ok, redirected, { () -> bridge.std__vector_NitroHeader_ in
       var __vector = bridge.create_std__vector_NitroHeader_(headers.count)
       for __item in headers {
@@ -31,9 +31,9 @@ public extension NitroResponse {
       } else {
         return .init()
       }
-    }(), { () -> bridge.std__optional_std__string_ in
+    }(), { () -> bridge.std__optional_std__shared_ptr_ArrayBuffer__ in
       if let __unwrappedValue = bodyBytes {
-        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        return bridge.create_std__optional_std__shared_ptr_ArrayBuffer__(__unwrappedValue.getArrayBuffer())
       } else {
         return .init()
       }
@@ -92,11 +92,11 @@ public extension NitroResponse {
   }
   
   @inline(__always)
-  var bodyBytes: String? {
-    return { () -> String? in
-      if bridge.has_value_std__optional_std__string_(self.__bodyBytes) {
-        let __unwrapped = bridge.get_std__optional_std__string_(self.__bodyBytes)
-        return String(__unwrapped)
+  var bodyBytes: ArrayBuffer? {
+    return { () -> ArrayBuffer? in
+      if bridge.has_value_std__optional_std__shared_ptr_ArrayBuffer__(self.__bodyBytes) {
+        let __unwrapped = bridge.get_std__optional_std__shared_ptr_ArrayBuffer__(self.__bodyBytes)
+        return ArrayBuffer(__unwrapped)
       } else {
         return nil
       }

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

@@ -57,11 +57,12 @@ namespace margelo::nitro::nitrofetch {
     std::optional<std::vector<NitroFormDataPart>> bodyFormData     SWIFT_PRIVATE;
     std::optional<double> timeoutMs     SWIFT_PRIVATE;
     std::optional<bool> followRedirects     SWIFT_PRIVATE;
+    std::optional<double> prefetchCacheTtlMs     SWIFT_PRIVATE;
     std::optional<std::string> requestId     SWIFT_PRIVATE;
 
   public:
     NitroRequest() = default;
-    explicit NitroRequest(std::string url, std::optional<NitroRequestMethod> method, std::optional<std::vector<NitroHeader>> headers, std::optional<std::string> bodyString, std::optional<std::string> bodyBytes, std::optional<std::vector<NitroFormDataPart>> bodyFormData, std::optional<double> timeoutMs, std::optional<bool> followRedirects, std::optional<std::string> requestId): url(url), method(method), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes), bodyFormData(bodyFormData), timeoutMs(timeoutMs), followRedirects(followRedirects), requestId(requestId) {}
+    explicit NitroRequest(std::string url, std::optional<NitroRequestMethod> method, std::optional<std::vector<NitroHeader>> headers, std::optional<std::string> bodyString, std::optional<std::string> bodyBytes, std::optional<std::vector<NitroFormDataPart>> bodyFormData, std::optional<double> timeoutMs, std::optional<bool> followRedirects, std::optional<double> prefetchCacheTtlMs, std::optional<std::string> requestId): url(url), method(method), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes), bodyFormData(bodyFormData), timeoutMs(timeoutMs), followRedirects(followRedirects), prefetchCacheTtlMs(prefetchCacheTtlMs), requestId(requestId) {}
 
   public:
     friend bool operator==(const NitroRequest& lhs, const NitroRequest& rhs) = default;
@@ -85,6 +86,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "followRedirects"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestId")))
       );
     }
@@ -98,6 +100,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData"), JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::toJSI(runtime, arg.bodyFormData));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.timeoutMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "followRedirects"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.followRedirects));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.prefetchCacheTtlMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "requestId"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.requestId));
       return obj;
     }
@@ -117,6 +120,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "followRedirects")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestId")))) return false;
       return true;
     }

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

@@ -35,6 +35,7 @@ namespace margelo::nitro::nitrofetch { struct NitroHeader; }
 #include "NitroHeader.hpp"
 #include <vector>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::nitrofetch {
 
@@ -50,11 +51,11 @@ namespace margelo::nitro::nitrofetch {
     bool redirected     SWIFT_PRIVATE;
     std::vector<NitroHeader> headers     SWIFT_PRIVATE;
     std::optional<std::string> bodyString     SWIFT_PRIVATE;
-    std::optional<std::string> bodyBytes     SWIFT_PRIVATE;
+    std::optional<std::shared_ptr<ArrayBuffer>> bodyBytes     SWIFT_PRIVATE;
 
   public:
     NitroResponse() = default;
-    explicit NitroResponse(std::string url, double status, std::string statusText, bool ok, bool redirected, std::vector<NitroHeader> headers, std::optional<std::string> bodyString, std::optional<std::string> bodyBytes): url(url), status(status), statusText(statusText), ok(ok), redirected(redirected), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes) {}
+    explicit NitroResponse(std::string url, double status, std::string statusText, bool ok, bool redirected, std::vector<NitroHeader> headers, std::optional<std::string> bodyString, std::optional<std::shared_ptr<ArrayBuffer>> bodyBytes): url(url), status(status), statusText(statusText), ok(ok), redirected(redirected), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes) {}
 
   public:
     friend bool operator==(const NitroResponse& lhs, const NitroResponse& rhs) = default;
@@ -77,7 +78,7 @@ namespace margelo::nitro {
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "redirected"))),
         JSIConverter<std::vector<margelo::nitro::nitrofetch::NitroHeader>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headers"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyString"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes")))
+        JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrofetch::NitroResponse& arg) {
@@ -89,7 +90,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "redirected"), JSIConverter<bool>::toJSI(runtime, arg.redirected));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "headers"), JSIConverter<std::vector<margelo::nitro::nitrofetch::NitroHeader>>::toJSI(runtime, arg.headers));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "bodyString"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.bodyString));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.bodyBytes));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes"), JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::toJSI(runtime, arg.bodyBytes));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -107,7 +108,7 @@ namespace margelo::nitro {
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "redirected")))) return false;
       if (!JSIConverter<std::vector<margelo::nitro::nitrofetch::NitroHeader>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "headers")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyString")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes")))) return false;
+      if (!JSIConverter<std::optional<std::shared_ptr<ArrayBuffer>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyBytes")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -118,11 +118,26 @@
   ],
   "packageManager": "yarn@3.6.1",
   "jest": {
-    "preset": "react-native",
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json"
+    ],
     "modulePathIgnorePatterns": [
       "<rootDir>/example/node_modules",
       "<rootDir>/lib/"
-    ]
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsconfig": {
+          "jsx": "react"
+        }
+      }
+    }
   },
   "release-it": {
     "git": false,

package/src/CurlGenerator.js

@@ -0,0 +1,31 @@
+function shellEscape(str) {
+    if (/^[a-zA-Z0-9._\-/:=@,+]+$/.test(str))
+        return str;
+    return "'" + str.replace(/'/g, "'\\''") + "'";
+}
+export function generateCurl(options) {
+    const parts = ['curl'];
+    if (options.method && options.method !== 'GET') {
+        parts.push('-X', shellEscape(options.method));
+    }
+    if (options.headers) {
+        for (const h of options.headers) {
+            if (h.key.toLowerCase() === 'prefetchkey')
+                continue;
+            parts.push('-H', shellEscape(`${h.key}: ${h.value}`));
+        }
+    }
+    if (options.body) {
+        const maxLen = 10_000;
+        const truncated = options.body.length > maxLen
+            ? options.body.slice(0, maxLen) + '...[truncated]'
+            : options.body;
+        parts.push('-d', shellEscape(truncated));
+    }
+    if (options.verbose)
+        parts.push('-v');
+    if (options.compressed)
+        parts.push('--compressed');
+    parts.push(shellEscape(options.url));
+    return parts.join(' ');
+}

package/src/Headers.js

@@ -0,0 +1,127 @@
+function normalizeName(name) {
+    return name.toLowerCase();
+}
+export class NitroHeaders {
+    _map;
+    constructor(init) {
+        this._map = new Map();
+        if (!init)
+            return;
+        if (init instanceof NitroHeaders) {
+            init._map.forEach((values, key) => {
+                this._map.set(key, [...values]);
+            });
+        }
+        else if (typeof init === 'object' &&
+            !Array.isArray(init) &&
+            typeof init.forEach === 'function' &&
+            typeof init.get === 'function') {
+            // Headers-like object (standard Headers or duck-typed)
+            init.forEach((value, key) => {
+                this._map.set(normalizeName(key), [value]);
+            });
+        }
+        else if (Array.isArray(init)) {
+            for (const entry of init) {
+                if (Array.isArray(entry) && entry.length >= 2) {
+                    // [string, string] tuple
+                    const key = normalizeName(String(entry[0]));
+                    const value = String(entry[1]);
+                    const existing = this._map.get(key);
+                    if (existing)
+                        existing.push(value);
+                    else
+                        this._map.set(key, [value]);
+                }
+                else if (entry &&
+                    typeof entry === 'object' &&
+                    'key' in entry &&
+                    'value' in entry) {
+                    // NitroHeader object
+                    const key = normalizeName(entry.key);
+                    const value = entry.value;
+                    const existing = this._map.get(key);
+                    if (existing)
+                        existing.push(value);
+                    else
+                        this._map.set(key, [value]);
+                }
+            }
+        }
+        else if (typeof init === 'object' && init !== null) {
+            const keys = Object.keys(init);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                const v = init[k];
+                if (v !== undefined) {
+                    this._map.set(normalizeName(k), [String(v)]);
+                }
+            }
+        }
+    }
+    append(name, value) {
+        const key = normalizeName(name);
+        const existing = this._map.get(key);
+        if (existing)
+            existing.push(value);
+        else
+            this._map.set(key, [value]);
+    }
+    delete(name) {
+        this._map.delete(normalizeName(name));
+    }
+    get(name) {
+        const values = this._map.get(normalizeName(name));
+        if (!values || values.length === 0)
+            return null;
+        return values.join(', ');
+    }
+    getSetCookie() {
+        return this._map.get('set-cookie') ?? [];
+    }
+    has(name) {
+        return this._map.has(normalizeName(name));
+    }
+    set(name, value) {
+        this._map.set(normalizeName(name), [value]);
+    }
+    forEach(callback, thisArg) {
+        const sortedKeys = Array.from(this._map.keys()).sort();
+        for (const key of sortedKeys) {
+            callback.call(thisArg, this._map.get(key).join(', '), key, this);
+        }
+    }
+    entries() {
+        const map = this._map;
+        const sortedKeys = Array.from(map.keys()).sort();
+        function* gen() {
+            for (const key of sortedKeys) {
+                yield [key, map.get(key).join(', ')];
+            }
+        }
+        return gen();
+    }
+    keys() {
+        const map = this._map;
+        const sortedKeys = Array.from(map.keys()).sort();
+        function* gen() {
+            for (const key of sortedKeys) {
+                yield key;
+            }
+        }
+        return gen();
+    }
+    values() {
+        const map = this._map;
+        const sortedKeys = Array.from(map.keys()).sort();
+        function* gen() {
+            for (const key of sortedKeys) {
+                yield map.get(key).join(', ');
+            }
+        }
+        return gen();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}

package/src/HermesProfiler.js

@@ -0,0 +1,22 @@
+export async function profileFetch(fn, outputPath) {
+    const hermes = global.HermesInternal;
+    if (!hermes) {
+        const result = await fn();
+        return { result };
+    }
+    const path = outputPath ?? `/tmp/nitrofetch-profile-${Date.now()}.cpuprofile`;
+    hermes.enableSamplingProfiler();
+    try {
+        const result = await fn();
+        return { result, profilePath: path };
+    }
+    finally {
+        hermes.disableSamplingProfiler();
+        try {
+            hermes.dumpSamplingProfiler(path);
+        }
+        catch {
+            // Profile dump may fail on some platforms
+        }
+    }
+}