[bun.js] Use `Headers` from WebKit instead of custom

4 files changed, 67 insertions, 15 deletions

diff --git a/integration/bunjs-only-snippets/globals.test.js b/integration/bunjs-only-snippets/globals.test.js
index 831bbd93f..b498e0e8e 100644
--- a/integration/bunjs-only-snippets/globals.test.js
+++ b/integration/bunjs-only-snippets/globals.test.js
@@ -16,7 +16,8 @@ it("extendable", () => {
     var Foo = class extends Class {};
     var bar = new Foo();
     expect(bar instanceof Class).toBe(true);
-    expect(Class.prototype instanceof Class).toBe(true);
+    expect(!!Class.prototype).toBe(true);
+    expect(typeof Class.prototype).toBe("object");
   }
   expect(true).toBe(true);
 });
diff --git a/integration/bunjs-only-snippets/html-rewriter.test.js b/integration/bunjs-only-snippets/html-rewriter.test.js
index a4ca965aa..68e2849d9 100644
--- a/integration/bunjs-only-snippets/html-rewriter.test.js
+++ b/integration/bunjs-only-snippets/html-rewriter.test.js
@@ -26,10 +26,6 @@ describe("HTMLRewriter", () => {
     expect(await res.text()).toBe("<div><span>replace</span></div>");
   });
 
-  it("exists globally", async () => {
-    expect(typeof HTMLRewriter).toBe("function");
-    expect(typeof HTMLRewriter.constructor).toBe("function");
-  });
   it("supports element handlers", async () => {
     var rewriter = new HTMLRewriter();
     rewriter.on("div", {
diff --git a/integration/bunjs-only-snippets/mmap.test.js b/integration/bunjs-only-snippets/mmap.test.js
index 03ce75e87..3dd3aadb9 100644
--- a/integration/bunjs-only-snippets/mmap.test.js
+++ b/integration/bunjs-only-snippets/mmap.test.js
@@ -10,13 +10,13 @@ it("mmap finalizer", async () => {
 
   map = null;
   Bun.gc(true);
-  await new Promise(resolve => setTimeout(resolve, 1));
+  await new Promise((resolve) => setTimeout(resolve, 1));
 });
 
-it('mmap passed to other syscalls', async () => {
+it("mmap passed to other syscalls", async () => {
   const map = Bun.mmap(path);
-  await Bun.write(path + '1', map);
-  const text = await (await Bun.file(path + '1')).text();
+  await Bun.write(path + "1", map);
+  const text = await (await Bun.file(path + "1")).text();
 
   expect(text).toBe(new TextDecoder().decode(map));
 });
@@ -46,4 +46,4 @@ it("mmap private", () => {
   map2[0] = 0;
   expect(map2[0]).toBe(0);
   expect(map[0]).toBe(old);
-});
\ No newline at end of file
+});
diff --git a/integration/bunjs-only-snippets/response.file.test.js b/integration/bunjs-only-snippets/response.file.test.js
index d094c0a62..6a879c758 100644
--- a/integration/bunjs-only-snippets/response.file.test.js
+++ b/integration/bunjs-only-snippets/response.file.test.js
@@ -2,12 +2,28 @@ import fs from "fs";
 import { it, expect } from "bun:test";
 import path from "path";
 
+function gc() {
+  Bun.gc(true);
+}
+
+// we must ensure that finalizers are run
+// so that the reference-counting logic is exercised
+function gcTick() {
+  gc();
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
 it("Bun.file not found returns ENOENT", async () => {
   try {
+    await gcTick();
     await Bun.file("/does/not/exist.txt").text();
+    await gcTick();
   } catch (exception) {
     expect(exception.code).toBe("ENOENT");
   }
+  await gcTick();
 });
 
 it("Bun.write('out.txt', 'string')", async () => {
@@ -17,11 +33,15 @@ it("Bun.write('out.txt', 'string')", async () => {
         fs.unlinkSync(path.join("/tmp", "out.txt"));
       } catch (e) {}
     }
-
+    await gcTick();
     await Bun.write("/tmp/out.txt", "string");
+    await gcTick();
     const out = Bun.file("/tmp/out.txt");
+    await gcTick();
     expect(await out.text()).toBe("string");
+    await gcTick();
     expect(await out.text()).toBe(fs.readFileSync("/tmp/out.txt", "utf8"));
+    await gcTick();
   }
 });
 
@@ -30,38 +50,47 @@ it("Bun.write blob", async () => {
     Bun.file("/tmp/response-file.test.txt"),
     Bun.file(path.join(import.meta.dir, "fetch.js.txt"))
   );
+  await gcTick();
   await Bun.write(Bun.file("/tmp/response-file.test.txt"), "blah blah blha");
+  await gcTick();
   await Bun.write(
     Bun.file("/tmp/response-file.test.txt"),
     new Uint32Array(1024)
   );
+  await gcTick();
   await Bun.write("/tmp/response-file.test.txt", new Uint32Array(1024));
+  await gcTick();
   expect(
     await Bun.write(
       new TextEncoder().encode("/tmp/response-file.test.txt"),
       new Uint32Array(1024)
     )
   ).toBe(new Uint32Array(1024).byteLength);
+  await gcTick();
 });
 
 it("Bun.file -> Bun.file", async () => {
   try {
     fs.unlinkSync(path.join("/tmp", "fetch.js.in"));
   } catch (e) {}
-
+  await gcTick();
   try {
     fs.unlinkSync(path.join("/tmp", "fetch.js.out"));
   } catch (e) {}
-
+  await gcTick();
   const file = path.join(import.meta.dir, "fetch.js.txt");
+  await gcTick();
   const text = fs.readFileSync(file, "utf8");
   fs.writeFileSync("/tmp/fetch.js.in", text, { mode: 0644 });
+  await gcTick();
   {
     const result = await Bun.write(
       Bun.file("/tmp/fetch.js.out"),
       Bun.file("/tmp/fetch.js.in")
     );
+    await gcTick();
     expect(await Bun.file("/tmp/fetch.js.out").text()).toBe(text);
+    await gcTick();
   }
 
   {
@@ -75,14 +104,18 @@ it("Bun.file -> Bun.file", async () => {
   }
 
   {
+    await gcTick();
     await Bun.write("/tmp/fetch.js.in", Bun.file("/tmp/fetch.js.out"));
+    await gcTick();
     expect(await Bun.file("/tmp/fetch.js.in").text()).toBe(text);
   }
 });
 
 it("Bun.file", async () => {
   const file = path.join(import.meta.dir, "fetch.js.txt");
+  await gcTick();
   expect(await Bun.file(file).text()).toBe(fs.readFileSync(file, "utf8"));
+  await gcTick();
 });
 
 it("Bun.file as a Blob", async () => {
@@ -92,27 +125,34 @@ it("Bun.file as a Blob", async () => {
   // internally, instead of a byte array, it stores the file path!
   // this enables several performance optimizations
   var blob = Bun.file(filePath);
+  await gcTick();
 
   // no size because we haven't read it from disk yet
   expect(blob.size).toBe(0);
+  await gcTick();
   // now it reads "./fetch.js.txt" from the filesystem
   // it's lazy, only loads once we ask for it
   // if it fails, the promise will reject at this point
   expect(await blob.text()).toBe(fixture);
+  await gcTick();
   // now that it's loaded, the size updates
   expect(blob.size).toBe(fixture.length);
+  await gcTick();
   // and it only loads once for _all_ blobs pointing to that file path
   // until all references are released
   expect((await blob.arrayBuffer()).byteLength).toBe(fixture.length);
+  await gcTick();
 
   const array = new Uint8Array(await blob.arrayBuffer());
+  await gcTick();
   const text = fixture;
   for (let i = 0; i < text.length; i++) {
     expect(array[i]).toBe(text.charCodeAt(i));
   }
+  await gcTick();
   expect(blob.size).toBe(fixture.length);
   blob = null;
-  Bun.gc(true);
+  await gcTick();
   await new Promise((resolve) => setTimeout(resolve, 1));
   // now we're back
   var blob = Bun.file(filePath);
@@ -121,9 +161,13 @@ it("Bun.file as a Blob", async () => {
 
 it("Response -> Bun.file", async () => {
   const file = path.join(import.meta.dir, "fetch.js.txt");
+  await gcTick();
   const text = fs.readFileSync(file, "utf8");
+  await gcTick();
   const response = new Response(Bun.file(file));
+  await gcTick();
   expect(await response.text()).toBe(text);
+  await gcTick();
 });
 
 it("Bun.file -> Response", async () => {
@@ -131,18 +175,29 @@ it("Bun.file -> Response", async () => {
   try {
     fs.unlinkSync("/tmp/fetch.js.out");
   } catch {}
-
+  await gcTick();
   const file = path.join(import.meta.dir, "fetch.js.txt");
+  await gcTick();
   const text = fs.readFileSync(file, "utf8");
+  await gcTick();
   const resp = await fetch("https://example.com");
+  await gcTick();
   expect(await Bun.write("/tmp/fetch.js.out", resp)).toBe(text.length);
+  await gcTick();
   expect(await Bun.file("/tmp/fetch.js.out").text()).toBe(text);
+  await gcTick();
 });
 
 it("Response -> Bun.file -> Response -> text", async () => {
+  await gcTick();
   const file = path.join(import.meta.dir, "fetch.js.txt");
+  await gcTick();
   const text = fs.readFileSync(file, "utf8");
+  await gcTick();
   const response = new Response(Bun.file(file));
+  await gcTick();
   const response2 = response.clone();
+  await gcTick();
   expect(await response2.text()).toBe(text);
+  await gcTick();
 });