Skip to content

Lightpanda: the headless browser designed for AI and automation

`ReadableStreamDefaultController`: add a new way to `enqueue` and throw error

Halil Durake460135d744e
diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
index f9bdec77a..60d8a117f 100644
--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig
+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
@@ -68,6 +68,48 @@ pub fn addPendingRead(self: *ReadableStreamDefaultController, local: *const js.L
return resolver.promise();
}
+/// Enqueues `chunk` to internal queue but doesn't resolve pending reads.
+/// This function solely exists to give no window for page JS to run when
+/// running it may introduce data races. Can still fail if stream is not readable.
+///
+/// TODO: Come up with a better name.
+pub fn enqueueNoSideEffects(self: *ReadableStreamDefaultController, chunk: Chunk) !void {
+ if (self._stream._state != .readable) {
+ return error.StreamNotReadable;
+ }
+ const chunk_copy = try chunk.dupe(self._arena);
+ return self._queue.append(self._arena, chunk_copy);
+}
+
+/// Resolves pending reads with queued chunks. Pairs with `enqueueNoSideEffects`.
+/// Call it once the producer no longer holds state that page JS could invalidate.
+pub fn fulfillPendingReads(self: *ReadableStreamDefaultController) void {
+ const exec = self._execution;
+ if (comptime lp.IS_DEBUG) {
+ if (exec.js.local == null) {
+ log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.fulfillPendingReads", .url = exec.url.* });
+ std.debug.assert(exec.js.local != null);
+ }
+ }
+
+ // Each resolve runs microtasks, so page JS can read, cancel or error the
+ // stream (or re-enter the producer) between iterations; both lists are
+ // re-checked every time.
+ while (self._pending_reads.items.len > 0 and self._queue.items.len > 0) {
+ const resolver = self._pending_reads.orderedRemove(0);
+ const chunk = self._queue.orderedRemove(0);
+ const result = ReadableStreamDefaultReader.ReadResult{
+ .done = false,
+ .value = .fromChunk(chunk),
+ };
+
+ var ls: js.Local.Scope = undefined;
+ exec.js.localScope(&ls);
+ defer ls.deinit();
+ ls.toLocal(resolver).resolve("stream fulfill pending read", result);
+ }
+}
+
pub fn enqueue(self: *ReadableStreamDefaultController, chunk: Chunk) !void {
if (self._stream._state != .readable) {
return error.StreamNotReadable;
@@ -168,6 +210,16 @@ pub fn close(self: *ReadableStreamDefaultController) !void {
}
pub fn doError(self: *ReadableStreamDefaultController, err: []const u8) !void {
+ return self.fail(err, false);
+}
+
+/// Like doError, but pending reads reject with a TypeError instead of the
+/// bare message, which is what native transforms (e.g. CompressionStream) throw.
+pub fn typeError(self: *ReadableStreamDefaultController, message: []const u8) !void {
+ return self.fail(message, true);
+}
+
+fn fail(self: *ReadableStreamDefaultController, err: []const u8, type_error: bool) !void {
if (self._stream._state != .readable) {
return;
}
@@ -177,7 +229,12 @@ pub fn doError(self: *ReadableStreamDefaultController, err: []const u8) !void {
// Reject all pending reads
for (self._pending_reads.items) |resolver| {
- self._execution.js.toLocal(resolver).reject("stream error", err);
+ const local_resolver = self._execution.js.toLocal(resolver);
+ if (type_error) {
+ local_resolver.rejectError("stream error", .{ .type_error = err });
+ } else {
+ local_resolver.reject("stream error", err);
+ }
}
self._pending_reads.clearRetainingCapacity();
}
diff --git a/src/browser/webapi/streams/TransformStream.zig b/src/browser/webapi/streams/TransformStream.zig
index c57f30fda..9dca4b991 100644
--- a/src/browser/webapi/streams/TransformStream.zig
+++ b/src/browser/webapi/streams/TransformStream.zig
@@ -184,6 +184,14 @@ pub const TransformStreamDefaultController = struct {
try self._stream._readable._controller.enqueue(chunk);
}
+ pub fn enqueueNoSideEffects(self: *TransformStreamDefaultController, chunk: ReadableStreamDefaultController.Chunk) !void {
+ try self._stream._readable._controller.enqueueNoSideEffects(chunk);
+ }
+
+ pub fn fulfillPendingReads(self: *TransformStreamDefaultController) void {
+ self._stream._readable._controller.fulfillPendingReads();
+ }
+
/// Enqueue a raw JS value, preserving its type. Used by the JS-facing API.
pub fn enqueueValue(self: *TransformStreamDefaultController, value: js.Value) !void {
try self._stream._readable._controller.enqueueValue(value);
@@ -193,6 +201,11 @@ pub const TransformStreamDefaultController = struct {
try self._stream._readable._controller.doError(reason);
}
+ pub fn typeError(self: *TransformStreamDefaultController, message: []const u8) !void {
+ try self._stream._readable._controller.typeError(message);
+ self._stream._writable._controller.doError(message);
+ }
+
pub fn terminate(self: *TransformStreamDefaultController) !void {
try self._stream._readable._controller.close();
}