Skip to content

Lightpanda: the headless browser designed for AI and automation

leverage new error -> reject mechanism

Karl Seguin3cac95063244
diff --git a/src/browser/tests/net/fetch.html b/src/browser/tests/net/fetch.html
index ce9cef066..297eb1adf 100644
--- a/src/browser/tests/net/fetch.html
+++ b/src/browser/tests/net/fetch.html
@@ -76,10 +76,16 @@
} catch (e) {
error = e.toString();
}
+
+ // A bad init rejects the promise; fetch() itself doesn't throw.
+ const pending = fetch('http://127.0.0.1:9582/xhr', { headers: { 'bad name': 'x' } });
+ const header_error = await pending.catch((e) => e.toString());
state.resolve();
await state.done(() => {
testing.expectEqual("TypeError: 'PUT' is unsupported in no-cors mode", error);
+ testing.expectEqual(true, pending instanceof Promise);
+ testing.expectEqual('TypeError: Invalid header name', header_error);
});
}
</script>
diff --git a/src/browser/tests/net/headers.html b/src/browser/tests/net/headers.html
index 7185c4dac..018aa09f7 100644
--- a/src/browser/tests/net/headers.html
+++ b/src/browser/tests/net/headers.html
@@ -205,18 +205,11 @@
}
// An invalid header name throws a TypeError.
-{
- let threw = false;
- try { new Headers([["a b", "x"]]); } catch (e) { threw = e instanceof TypeError; }
- testing.expectEqual(true, threw);
-}
+testing.expectError('TypeError: Invalid header name', () => new Headers([["a b", "x"]]));
+testing.expectError('TypeError: Invalid header name', () => new Headers({ "a b": "x" }));
// A value with a forbidden byte (here an interior newline) throws a TypeError.
-{
- let threw = false;
- try { new Headers([["x", "a\nb"]]); } catch (e) { threw = e instanceof TypeError; }
- testing.expectEqual(true, threw);
-}
+testing.expectError('TypeError: Invalid header value', () => new Headers([["x", "a\nb"]]));
// A value with a code point above U+00FF cannot be a byte string: TypeError.
{
diff --git a/src/browser/webapi/net/Fetch.zig b/src/browser/webapi/net/Fetch.zig
index 48be2ffcd..e2d5f8e47 100644
--- a/src/browser/webapi/net/Fetch.zig
+++ b/src/browser/webapi/net/Fetch.zig
@@ -73,17 +73,8 @@ pub const Completion = struct {
};
pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promise {
- const resolver = exec.js.local.?.createPromiseResolver();
-
- // A bad RequestInit (e.g. an invalid priority) must reject the promise,
- // not throw synchronously.
- const request = Request.init(input, options, exec) catch {
- // Request.init may have set a specific message (see Local.typeError).
- const env = exec.js.env;
- defer env.error_message = null;
- resolver.rejectError("fetch init error", .{ .type_error = env.error_message orelse "Failed to construct Request" });
- return resolver.promise();
- };
+ // Errors returned from here reject the promise (see Caller.handleError).
+ const request = try Request.init(input, options, exec);
// This Request is never exposed to JS. makeRequest dupes the url/body
// into the transfer, so nothing references it once we return.
@@ -91,10 +82,10 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
defer request.releaseRef(exec.page);
if (request._mode == .navigate) {
- resolver.rejectError("fetch request mode error", .{ .type_error = "Fetch can't be navigate" });
- return resolver.promise();
+ return exec.js.typeError("Fetch can't be navigate");
}
+ const resolver = exec.js.local.?.createPromiseResolver();
if (request._signal) |signal| {
if (signal._aborted) {
resolver.reject("fetch aborted", try AbortSignal.reasonJsValue(signal._reason, exec.js.local.?));
@@ -103,10 +94,7 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
}
const body = request.bodyBytes() catch |err| switch (err) {
- error.TypeError => {
- resolver.rejectError("fetch body error", .{ .type_error = "Failed to read ReadableStream body" });
- return resolver.promise();
- },
+ error.TypeError => return exec.js.typeError("Failed to read ReadableStream body"),
else => return err,
};
diff --git a/src/browser/webapi/net/Headers.zig b/src/browser/webapi/net/Headers.zig
index ca0b3ade4..778be8281 100644
--- a/src/browser/webapi/net/Headers.zig
+++ b/src/browser/webapi/net/Headers.zig
@@ -51,12 +51,12 @@ pub fn initGuarded(opts_: ?InitOpts, guard: Guard, exec: *const Execution) !*Hea
.obj => |obj| break :blk try KeyValueList.copy(exec.page_arena, obj._list),
.js_obj => |js_obj| {
var list = try KeyValueList.fromJsObject(exec.page_arena, js_obj, normalizeHeaderName, exec.local_arena);
- try validateAndNormalize(&list);
+ try validateAndNormalize(&list, exec);
break :blk list;
},
.strings => |kvs| {
var list = try KeyValueList.fromArray(exec.page_arena, kvs, normalizeHeaderName, exec.local_arena);
- try validateAndNormalize(&list);
+ try validateAndNormalize(&list, exec);
break :blk list;
},
}
@@ -393,16 +393,16 @@ fn normalizeValue(value: []const u8, exec: *const Execution) ![]const u8 {
/// Validate names and normalize/validate values for a script-provided header
/// init, trimming values in place. The trim is allocation-free (see
/// `String.trim`), so an untrimmed value keeps its original storage.
-fn validateAndNormalize(list: *KeyValueList) !void {
+fn validateAndNormalize(list: *KeyValueList, exec: *const Execution) !void {
for (list._entries.items) |*entry| {
// A valid header name is exactly a non-empty HTTP token.
if (Mime.isHttpToken(entry.name.str()) == false) {
- return error.TypeError;
+ return exec.js.typeError("Invalid header name");
}
// A valid header value is a byte string without NUL, LF or CR.
const trimmed = entry.value.trim(&Mime.HTTP_WHITESPACE);
if (Mime.isHttpHeaderValue(trimmed.str()) == false) {
- return error.TypeError;
+ return exec.js.typeError("Invalid header value");
}
entry.value = trimmed;
}