add hash support to URL stitch

Author: mookums

src/browser/html/location.zig

@@ -44,17 +44,12 @@ pub const Location = struct {
     }
 
     pub fn set_hash(_: *const Location, hash: []const u8, page: *Page) !void {
-        const current_url = page.url.raw;
-
-        const base_without_hash = if (std.mem.indexOfScalar(u8, current_url, '#')) |pos|
-            current_url[0..pos]
+        const normalized_hash = if (hash[0] == '#')
+            hash
         else
-            current_url;
-
-        const normalized_hash = std.mem.trimStart(u8, hash, "#");
-        const new_url = try std.fmt.allocPrint(page.arena, "{s}#{s}", .{ base_without_hash, normalized_hash });
+            try std.fmt.allocPrint(page.arena, "#{s}", .{hash});
 
-        return page.navigateFromWebAPI(new_url, .{ .reason = .script }, .replace);
+        return page.navigateFromWebAPI(normalized_hash, .{ .reason = .script }, .replace);
     }
 
     pub fn get_protocol(self: *Location) []const u8 {

src/browser/navigation/Navigation.zig

@@ -228,7 +228,9 @@ pub fn navigate(
     const committed = try page.js.createPromiseResolver(.page);
     const finished = try page.js.createPromiseResolver(.page);
 
-    const new_url = try URL.parse(url, null);
+    const new_url_string = try URL.stitch(arena, url, page.url.raw, .{});
+    const new_url = try URL.parse(new_url_string, null);
+
     const is_same_document = try page.url.eqlDocument(&new_url, arena);
 
     switch (kind) {

src/browser/page.zig

@@ -1084,7 +1084,6 @@ pub const Page = struct {
             if (try self.url.eqlDocument(&new_url, session.transfer_arena)) {
                 self.url = new_url;
                 try self.window.changeLocation(self.url.raw, self);
-
                 try session.navigation.updateEntries(stitched_url, kind, self, true);
                 return;
             }

src/url.zig

@@ -81,16 +81,34 @@ pub const URL = struct {
     /// For URLs without a path, it will add src as the path.
     pub fn stitch(
         allocator: Allocator,
-        path: []const u8,
-        base: []const u8,
+        _path: []const u8,
+        _base: []const u8,
         comptime opts: StitchOpts,
     ) !StitchReturn(opts) {
-        if (base.len == 0 or isCompleteHTTPUrl(path)) {
-            return simpleStitch(allocator, path, opts);
+        if (_base.len == 0 or isCompleteHTTPUrl(_path)) {
+            return simpleStitch(allocator, _path, opts);
         }
 
+        if (_path.len == 0) {
+            return simpleStitch(allocator, _base, opts);
+        }
+
+        // base should get stripped of its hash whenever we are stitching.
+        const base = if (std.mem.indexOfScalar(u8, _base, '#')) |hash_pos|
+            _base[0..hash_pos]
+        else
+            _base;
+
+        const path_hash_start = std.mem.indexOfScalar(u8, _path, '#');
+        const path = if (path_hash_start) |pos| _path[0..pos] else _path;
+        const hash = if (path_hash_start) |pos| _path[pos..] else "";
+
+        // if path is just hash, we just append it to base.
         if (path.len == 0) {
-            return simpleStitch(allocator, base, opts);
+            if (comptime opts.null_terminated) {
+                return std.fmt.allocPrintSentinel(allocator, "{s}{s}", .{ base, hash }, 0);
+            }
+            return std.fmt.allocPrint(allocator, "{s}{s}", .{ base, hash });
         }
 
         if (std.mem.startsWith(u8, path, "//")) {
@@ -101,9 +119,9 @@ pub const URL = struct {
 
             const protocol = base[0..index];
             if (comptime opts.null_terminated) {
-                return std.fmt.allocPrintSentinel(allocator, "{s}:{s}", .{ protocol, path }, 0);
+                return std.fmt.allocPrintSentinel(allocator, "{s}:{s}{s}", .{ protocol, path, hash }, 0);
             }
-            return std.fmt.allocPrint(allocator, "{s}:{s}", .{ protocol, path });
+            return std.fmt.allocPrint(allocator, "{s}:{s}{s}", .{ protocol, path, hash });
         }
 
         // Quick hack because domains have to be at least 3 characters.
@@ -133,7 +151,10 @@ pub const URL = struct {
 
         // We preallocate all of the space possibly needed.
         // This is the root, old_path, new path, 3 slashes and perhaps a null terminated slot.
-        var out = try allocator.alloc(u8, root.len + old_path.len + path.len + 3 + if (comptime opts.null_terminated) 1 else 0);
+        var out = try allocator.alloc(
+            u8,
+            root.len + old_path.len + path.len + hash.len + 3 + if (comptime opts.null_terminated) 1 else 0,
+        );
         var end: usize = 0;
         @memmove(out[0..root.len], root);
         end += root.len;
@@ -180,6 +201,11 @@ pub const URL = struct {
             read += 1;
         }
 
+        if (hash.len > 0) {
+            @memmove(out[write .. write + hash.len], hash);
+            write += hash.len;
+        }
+
         if (comptime opts.null_terminated) {
             // we always have an extra space
             out[write] = 0;