diff --git a/src/apiweb.zig b/src/apiweb.zig index 87197b51..9eb7f936 100644 --- a/src/apiweb.zig +++ b/src/apiweb.zig @@ -7,6 +7,7 @@ const HTML = @import("html/html.zig"); const Events = @import("events/event.zig"); const XHR = @import("xhr/xhr.zig"); const Storage = @import("storage/storage.zig"); +const URL = @import("url/url.zig"); pub const HTMLDocument = @import("html/document.zig").HTMLDocument; @@ -18,4 +19,5 @@ pub const Interfaces = generate.Tuple(.{ HTML.Interfaces, XHR.Interfaces, Storage.Interfaces, + URL.Interfaces, }); diff --git a/src/run_tests.zig b/src/run_tests.zig index 3261a9eb..275b48ad 100644 --- a/src/run_tests.zig +++ b/src/run_tests.zig @@ -10,6 +10,7 @@ const apiweb = @import("apiweb.zig"); const Window = @import("html/window.zig").Window; const xhr = @import("xhr/xhr.zig"); const storage = @import("storage/storage.zig"); +const url = @import("url/url.zig"); const documentTestExecFn = @import("dom/document.zig").testExecFn; const HTMLDocumentTestExecFn = @import("html/document.zig").testExecFn; @@ -30,6 +31,7 @@ const EventTestExecFn = @import("events/event.zig").testExecFn; const XHRTestExecFn = xhr.testExecFn; const ProgressEventTestExecFn = @import("xhr/progress_event.zig").testExecFn; const StorageTestExecFn = storage.testExecFn; +const URLTestExecFn = url.testExecFn; pub const Types = jsruntime.reflect(apiweb.Interfaces); @@ -95,6 +97,7 @@ fn testsAllExecFn( ProgressEventTestExecFn, ProcessingInstructionTestExecFn, StorageTestExecFn, + URLTestExecFn, }; inline for (testFns) |testFn| { diff --git a/src/url/url.zig b/src/url/url.zig new file mode 100644 index 00000000..7a627196 --- /dev/null +++ b/src/url/url.zig @@ -0,0 +1,159 @@ +const std = @import("std"); + +const jsruntime = @import("jsruntime"); +const Case = jsruntime.test_utils.Case; +const checkCases = jsruntime.test_utils.checkCases; +const generate = @import("../generate.zig"); + +pub const Interfaces = generate.Tuple(.{ + URL, + URLSearchParams, +}); + +// https://url.spec.whatwg.org/#url +// +// TODO we could avoid many of these getter string allocation in two differents +// way: +// +// 1. We can eventually get the slice of scheme *with* the following char in +// the underlying string. But I don't know if it's possible and how to do that. +// I mean, if the rawuri contains `https://foo.bar`, uri.scheme is a slice +// containing only `https`. I want `https:` so, in theory, I don't need to +// allocate data, I should be able to retrieve the scheme + the following `:` +// from rawuri. +// +// 2. The other way would bu to copy the `std.Uri` code to ahve a dedicated +// parser including the characters we want for the web API. +pub const URL = struct { + rawuri: []const u8, + uri: std.Uri, + + pub const mem_guarantied = true; + + pub fn constructor(alloc: std.mem.Allocator, url: []const u8, base: ?[]const u8) !URL { + const raw = try std.mem.concat(alloc, u8, &[_][]const u8{ url, base orelse "" }); + errdefer alloc.free(raw); + + const uri = std.Uri.parse(raw) catch { + return error.TypeError; + }; + + return .{ + .rawuri = raw, + .uri = uri, + }; + } + + pub fn deinit(self: *URL, alloc: std.mem.Allocator) void { + alloc.free(self.rawuri); + } + + // the caller must free the returned string. + // TODO return a disposable string + // https://github.com/lightpanda-io/jsruntime-lib/issues/195 + pub fn get_href(self: URL, alloc: std.mem.Allocator) ![]const u8 { + var buf = std.ArrayList(u8).init(alloc); + defer buf.deinit(); + + try self.uri.writeToStream(.{ + .scheme = true, + .authentication = true, + .authority = true, + .path = true, + .query = true, + .fragment = true, + }, buf.writer()); + return try buf.toOwnedSlice(); + } + + // the caller must free the returned string. + // TODO return a disposable string + // https://github.com/lightpanda-io/jsruntime-lib/issues/195 + pub fn get_protocol(self: *URL, alloc: std.mem.Allocator) ![]const u8 { + return try std.mem.concat(alloc, u8, &[_][]const u8{ self.uri.scheme, ":" }); + } + + pub fn get_username(self: *URL) []const u8 { + return self.uri.user orelse ""; + } + + pub fn get_password(self: *URL) []const u8 { + return self.uri.password orelse ""; + } + + pub fn get_host(self: *URL) []const u8 { + return self.uri.host orelse ""; + } + + pub fn get_hostname(self: *URL) []const u8 { + return self.uri.host orelse ""; + } + + // the caller must free the returned string. + // TODO return a disposable string + // https://github.com/lightpanda-io/jsruntime-lib/issues/195 + pub fn get_port(self: *URL, alloc: std.mem.Allocator) ![]const u8 { + if (self.uri.port == null) return try alloc.dupe(u8, ""); + + var buf = std.ArrayList(u8).init(alloc); + defer buf.deinit(); + + try std.fmt.formatInt(self.uri.port.?, 10, .lower, .{}, buf.writer()); + return try buf.toOwnedSlice(); + } + + pub fn get_pathname(self: *URL) []const u8 { + if (self.uri.path.len == 0) return "/"; + return self.uri.path; + } + + // the caller must free the returned string. + // TODO return a disposable string + // https://github.com/lightpanda-io/jsruntime-lib/issues/195 + pub fn get_search(self: *URL, alloc: std.mem.Allocator) ![]const u8 { + if (self.uri.query == null) return try alloc.dupe(u8, ""); + + return try std.mem.concat(alloc, u8, &[_][]const u8{ "?", self.uri.query.? }); + } + + // the caller must free the returned string. + // TODO return a disposable string + // https://github.com/lightpanda-io/jsruntime-lib/issues/195 + pub fn get_hash(self: *URL, alloc: std.mem.Allocator) ![]const u8 { + if (self.uri.fragment == null) return try alloc.dupe(u8, ""); + + return try std.mem.concat(alloc, u8, &[_][]const u8{ "#", self.uri.fragment.? }); + } + + pub fn _toJSON(self: *URL, alloc: std.mem.Allocator) ![]const u8 { + return try self.get_href(alloc); + } +}; + +// https://url.spec.whatwg.org/#interface-urlsearchparams +pub const URLSearchParams = struct { + pub const mem_guarantied = true; +}; + +// Tests +// ----- + +pub fn testExecFn( + _: std.mem.Allocator, + js_env: *jsruntime.Env, +) anyerror!void { + var url = [_]Case{ + .{ .src = "var url = new URL('https://foo.bar/path?query#fragment')", .ex = "undefined" }, + .{ .src = "url.href", .ex = "https://foo.bar/path?query#fragment" }, + .{ .src = "url.protocol", .ex = "https:" }, + .{ .src = "url.username", .ex = "" }, + .{ .src = "url.password", .ex = "" }, + .{ .src = "url.host", .ex = "foo.bar" }, + .{ .src = "url.hostname", .ex = "foo.bar" }, + .{ .src = "url.port", .ex = "" }, + .{ .src = "url.pathname", .ex = "/path" }, + .{ .src = "url.search", .ex = "?query" }, + .{ .src = "url.hash", .ex = "#fragment" }, + }; + try checkCases(js_env, &url); +}