fix: response correctly returns instance instead of promise

BREAKING CHANGE: Response returns the instance rather than a promise in all cases

Author: acostalima

src/ArrayBufferResponse.js

@@ -0,0 +1,21 @@
+import { toByteArray } from "base64-js";
+import Response from "./Response";
+
+class ArrayBufferResponse extends Response {
+    constructor(base64, options) {
+        const buffer = toByteArray(base64);
+        super(buffer, options);
+        this._base64 = base64;
+    }
+
+    clone() {
+        return new ArrayBufferResponse(this._base64, {
+            status: this.status,
+            statusText: this.statusText,
+            headers: new Headers(this.headers),
+            url: this.url,
+        });
+    }
+}
+
+export default ArrayBufferResponse;

src/BlobResponse.js

@@ -0,0 +1,21 @@
+import BlobManager from "react-native/Libraries/Blob/BlobManager";
+import Response from "./Response";
+
+class BlobResponse extends Response {
+    constructor(blobData, options) {
+        const blob = BlobManager.createFromOptions(blobData);
+        super(blob, options);
+        this._blobData = blobData;
+    }
+
+    clone() {
+        return new BlobResponse(this._blobData, {
+            status: this.status,
+            statusText: this.statusText,
+            headers: new Headers(this.headers),
+            url: this.url,
+        });
+    }
+}
+
+export default BlobResponse;

src/Fetch.js

@@ -2,8 +2,8 @@ import { Networking } from "react-native";
 import pDefer from "p-defer";
 import Request from "./Request";
 import Response from "./Response";
-import StreamBlobResponse from "./StreamBlobResponse";
-import StreamArrayBufferResponse from "./StreamArrayBufferResponse";
+import BlobResponse from "./BlobResponse";
+import ArrayBufferResponse from "./ArrayBufferResponse";
 
 class AbortError extends Error {
     constructor() {
@@ -232,24 +232,19 @@ class Fetch {
         let ResponseClass;
 
         if (this._nativeResponseType === "blob") {
-            ResponseClass = StreamBlobResponse;
+            ResponseClass = BlobResponse;
         }
 
         if (this._nativeResponseType === "base64") {
-            ResponseClass = StreamArrayBufferResponse;
+            ResponseClass = ArrayBufferResponse;
         }
 
         try {
-            this._response = await new ResponseClass(
-                this._nativeResponse,
-                this._stream,
-                this._streamController,
-                {
-                    status: this._responseStatus,
-                    url: this._responseUrl,
-                    headers: this._nativeResponseHeaders,
-                }
-            );
+            this._response = new ResponseClass(this._nativeResponse, {
+                status: this._responseStatus,
+                url: this._responseUrl,
+                headers: this._nativeResponseHeaders,
+            });
             this._deferredPromise.resolve(this._response);
         } catch (error) {
             this._deferredPromise.reject(error);

src/StreamArrayBufferResponse.js

@@ -1856,4 +1856,53 @@ test("fetch method", (t) => {
             t.eq(await res3.text(), "bar4");
         });
     });
+
+    t.test("cloning", (t) => {
+        t.test("cloning response from text stream", async (t) => {
+            const url = new URL("/stream", BASE_URL);
+            const res = await fetch(url, {
+                reactNative: { textStreaming: true },
+            });
+            const clone = res.clone();
+            const stream = await clone.body;
+            const text = new TextDecoder().decode(await drainStream(stream));
+
+            t.ok(
+                stream instanceof ReadableStream,
+                "Response implements streaming body"
+            );
+            t.eq(text, "Hello world!");
+        });
+
+        t.test("cloning blob response", async (t) => {
+            const url = new URL("/request", BASE_URL);
+            const res = await fetch(url, {
+                headers: {
+                    Accept: "application/json",
+                },
+            });
+            const clone = res.clone();
+            const json = await clone.json();
+            t.eq(json.headers.accept, "application/json");
+        });
+
+        t.test("cloning array buffer response", async (t) => {
+            const url = new URL("/binary", BASE_URL);
+            const res = await fetch(url, {
+                reactNative: {
+                    __nativeResponseType: "base64",
+                },
+            });
+            const clone = res.clone();
+            const buf = await clone.arrayBuffer();
+
+            t.ok(buf instanceof ArrayBuffer, "buf is an ArrayBuffer instance");
+            t.eq(buf.byteLength, 256, "buf.byteLength is correct");
+
+            const expected = Array.from({ length: 256 }, (_, i) => i);
+            const actual = Array.from(new Uint8Array(buf));
+
+            t.eq(actual, expected);
+        });
+    });
 });