chore: move more cases to new typeError helper

https://github.com/lightpanda-io/browser/pull/3403 added a typeError helper and
this commits moves a few more callers to it.

src/browser/tests/cookie_store.html

@@ -362,3 +362,28 @@
     testing.expectEqual('ev-onchange', capturedName);
   });
 </script>
+
+<script id=rejections type=module>
+  // Invalid calls reject with a TypeError rather than throwing.
+  async function rejection(fn) {
+    const promise = fn();
+    try {
+      await promise;
+      return 'resolved';
+    } catch (e) {
+      return `${e.name}: ${e.message}`;
+    }
+  }
+
+  const state = await testing.async();
+  const results = [
+    await rejection(() => cookieStore.get()),
+    await rejection(() => cookieStore.set('no-value')),
+  ];
+  state.resolve();
+
+  await state.done(() => {
+    testing.expectEqual('TypeError: get requires a name or url', results[0]);
+    testing.expectEqual('TypeError: value is required', results[1]);
+  });
+</script>

src/browser/tests/streams/readable_stream.html

@@ -397,3 +397,56 @@
     testing.expectEqual('function', typeof stream.getReader);
   }
 </script>
+
+<script id=promise_rejections type=module>
+  // Each call returns a promise that rejects with a TypeError; none throws.
+  async function rejection(fn) {
+    const promise = fn();
+    if (!(promise instanceof Promise)) {
+      return 'not a promise';
+    }
+    try {
+      await promise;
+      return 'resolved';
+    } catch (e) {
+      return `${e.name}: ${e.message}`;
+    }
+  }
+
+  const state = await testing.async();
+
+  const released = new WritableStream().getWriter();
+  released.releaseLock();
+
+  const closed = new WritableStream().getWriter();
+  await closed.close();
+
+  const reader = new ReadableStream().getReader();
+  reader.releaseLock();
+
+  const locked = new ReadableStream();
+  locked.getReader();
+
+  const results = [
+    await rejection(() => released.write('x')),
+    await rejection(() => released.close()),
+    await rejection(() => released.closed),
+    await rejection(() => closed.write('x')),
+    await rejection(() => closed.close()),
+    await rejection(() => reader.cancel()),
+    await rejection(() => locked.pipeTo(new WritableStream())),
+  ];
+  state.resolve();
+
+  await state.done(() => {
+    testing.expectEqual([
+      'TypeError: Writer has been released',
+      'TypeError: Writer has been released',
+      'TypeError: Writer has been released',
+      'TypeError: Stream is not writable',
+      'TypeError: Stream is not writable',
+      'TypeError: Reader has been released',
+      'TypeError: ReadableStream is locked',
+    ], results);
+  });
+</script>

src/browser/webapi/storage/CookieStore.zig

@@ -259,11 +259,11 @@ pub fn get(_: *CookieStore, input: ?GetInput, exec: *const Execution) !js.Promis
 
     if (name == null and url == null) {
         // Unlike getAll(), get() requires a name or url
-        return local.rejectPromise(.{ .type_error = "get requires a name or url" });
+        return local.typeError("get requires a name or url");
     }
 
     const items = matchCookies(exec, name, url, true) catch |err| {
-        return local.rejectPromise(.{ .type_error = @errorName(err) });
+        return local.typeError(@errorName(err));
     };
 
     if (items.len == 0) {
@@ -281,7 +281,7 @@ pub fn getAll(_: *CookieStore, input: ?GetInput, exec: *const Execution) !js.Pro
     } else .{ null, null };
 
     const items = matchCookies(exec, name, url, false) catch |err| {
-        return local.rejectPromise(.{ .type_error = @errorName(err) });
+        return local.typeError(@errorName(err));
     };
     return local.resolvePromise(items);
 }
@@ -293,12 +293,12 @@ pub fn set(_: *CookieStore, input: SetInput, value: ?[]const u8, exec: *const Ex
         .options => |o| o,
         .name => |n| .{
             .name = n,
-            .value = value orelse return local.rejectPromise(.{ .type_error = "value is required" }),
+            .value = value orelse return local.typeError("value is required"),
         },
     };
 
     storeCookie(exec, init, false) catch |err| {
-        return local.rejectPromise(.{ .type_error = @errorName(err) });
+        return local.typeError(@errorName(err));
     };
 
     return local.resolvePromise({});
@@ -324,7 +324,7 @@ pub fn delete(_: *CookieStore, input: DeleteInput, exec: *const Execution) !js.P
         .sameSite = .strict,
         .partitioned = opts.partitioned,
     }, true) catch |err| {
-        return local.rejectPromise(.{ .type_error = @errorName(err) });
+        return local.typeError(@errorName(err));
     };
 
     return local.resolvePromise({});

src/browser/webapi/streams/ReadableStream.zig

@@ -315,7 +315,7 @@ fn pipeThrough(self: *ReadableStream, transform: PipeTransform, exec: *const Exe
 /// Returns a promise that resolves when piping is complete.
 pub fn pipeTo(self: *ReadableStream, destination: *WritableStream, exec: *const Execution) !js.Promise {
     if (self.getLocked()) {
-        return exec.js.local.?.rejectPromise(.{ .type_error = "ReadableStream is locked" });
+        return exec.js.typeError("ReadableStream is locked");
     }
 
     const local = exec.js.local.?;

src/browser/webapi/streams/ReadableStreamDefaultReader.zig

@@ -97,7 +97,7 @@ pub fn releaseLock(self: *ReadableStreamDefaultReader) void {
 
 pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?[]const u8, exec: *const Execution) !js.Promise {
     const stream = self._stream orelse {
-        return exec.js.local.?.rejectPromise(.{ .type_error = "Reader has been released" });
+        return exec.js.typeError("Reader has been released");
     };
 
     self.releaseLock();

src/browser/webapi/streams/WritableStreamDefaultWriter.zig

@@ -34,11 +34,11 @@ pub fn init(stream: *WritableStream, exec: *const Execution) !*WritableStreamDef
 pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const Execution) !js.Promise {
     const local = exec.js.local.?;
     const stream = self._stream orelse {
-        return local.rejectPromise(.{ .type_error = "Writer has been released" });
+        return local.typeError("Writer has been released");
     };
 
     if (stream._state != .writable) {
-        return local.rejectPromise(.{ .type_error = "Stream is not writable" });
+        return local.typeError("Stream is not writable");
     }
 
     try stream.writeChunk(chunk, exec);
@@ -49,11 +49,11 @@ pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const E
 pub fn close(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Promise {
     const local = exec.js.local.?;
     const stream = self._stream orelse {
-        return local.rejectPromise(.{ .type_error = "Writer has been released" });
+        return local.typeError("Writer has been released");
     };
 
     if (stream._state != .writable) {
-        return local.rejectPromise(.{ .type_error = "Stream is not writable" });
+        return local.typeError("Stream is not writable");
     }
 
     try stream.closeStream(exec);
@@ -71,7 +71,7 @@ pub fn releaseLock(self: *WritableStreamDefaultWriter) void {
 pub fn getClosed(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Promise {
     const local = exec.js.local.?;
     const stream = self._stream orelse {
-        return local.rejectPromise(.{ .type_error = "Writer has been released" });
+        return local.typeError("Writer has been released");
     };
 
     if (stream._state == .closed) {