fix(html): correct relative link depth on default-module subpages

Symbol pages are written to `{short_path.path}/~/{name}.html` for every
module, including the main entrypoint. But `href_path_resolve` hard-coded
the main entrypoint to a directory depth of 1 when computing the `../`
prefix for links back to the root.

That is only correct when the main module's path is `.` (the usual
single-package case). When several entrypoints share a common ancestor,
the main module gets a deeper path (e.g. `index.ts`), so its symbol pages
live two directories deep yet linked back to the root with a single
`../` — producing 404s for stylesheets, search results and cross-links on
those subpages.

Compute the depth from the actual number of path segments instead,
treating `.` as zero segments so the common case is unchanged.

Author: crowlbot

src/html/util.rs

@@ -377,17 +377,25 @@ pub fn href_path_resolve(
   current: UrlResolveKind,
   target: UrlResolveKind,
 ) -> String {
-  let backs = match current {
-    UrlResolveKind::File { file } => "../".repeat(if file.is_main {
-      1
+  // The number of directories a file's page is nested under, relative to the
+  // output root. A page lives at `{file.path}/index.html` (or, for a symbol,
+  // `{file.path}/~/{symbol}.html`), so the depth is the number of segments in
+  // `file.path`. The main entrypoint is rewritten to `.`, which adds no
+  // directory, so it counts as zero segments. Previously the main entrypoint
+  // was hard-coded to a depth of 1; that is only correct when its path is `.`
+  // and produced broken `../` links whenever the main module had a deeper path
+  // (e.g. when multiple entrypoints share a common ancestor).
+  fn path_depth(file: &ShortPath) -> usize {
+    if file.path == "." {
+      0
     } else {
       file.path.split('/').count()
-    }),
-    UrlResolveKind::Symbol { file, .. } => "../".repeat(if file.is_main {
-      1
-    } else {
-      file.path.split('/').count() + 1
-    }),
+    }
+  }
+
+  let backs = match current {
+    UrlResolveKind::File { file } => "../".repeat(path_depth(file)),
+    UrlResolveKind::Symbol { file, .. } => "../".repeat(path_depth(file) + 1),
     UrlResolveKind::Root => String::new(),
     UrlResolveKind::AllSymbols => String::from("./"),
     UrlResolveKind::Category { .. } => String::from("./"),
@@ -955,3 +963,87 @@ pub fn slugify(name: &str) -> String {
     .replace_all(&name.to_lowercase(), "")
     .replace(' ', "-")
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use deno_ast::ModuleSpecifier;
+
+  fn short_path(path: &str, is_main: bool) -> ShortPath {
+    ShortPath {
+      path: path.to_string(),
+      specifier: ModuleSpecifier::parse("file:///mod.ts").unwrap(),
+      is_main,
+    }
+  }
+
+  #[test]
+  fn href_path_resolve_main_entrypoint_depth() {
+    // The main entrypoint rewritten to `.` has no directory of its own, so its
+    // symbol pages live at `./~/Foo.html` (one level deep) and link back to the
+    // root with a single `../`.
+    let main_root = short_path(".", true);
+    assert_eq!(
+      href_path_resolve(
+        UrlResolveKind::Symbol {
+          file: &main_root,
+          symbol: "Foo",
+        },
+        UrlResolveKind::Root,
+      ),
+      "../",
+    );
+
+    // When the main entrypoint has a deeper path (e.g. several entrypoints share
+    // a common ancestor, so the main module is `index.ts`), its symbol page
+    // lives at `index.ts/~/Foo.html` — two levels deep — and must reach the root
+    // with `../../`. Regression test for incorrect `../` links on default-module
+    // subpages.
+    let main_nested = short_path("index.ts", true);
+    assert_eq!(
+      href_path_resolve(
+        UrlResolveKind::Symbol {
+          file: &main_nested,
+          symbol: "Foo",
+        },
+        UrlResolveKind::Root,
+      ),
+      "../../",
+    );
+    // Linking to the all-symbols page from such a subpage must also climb out.
+    assert_eq!(
+      href_path_resolve(
+        UrlResolveKind::Symbol {
+          file: &main_nested,
+          symbol: "Foo",
+        },
+        UrlResolveKind::AllSymbols,
+      ),
+      "../.././all_symbols.html",
+    );
+  }
+
+  #[test]
+  fn href_path_resolve_non_main_unchanged() {
+    let file = short_path("foo", false);
+    // index page: `foo/index.html` -> one level deep.
+    assert_eq!(
+      href_path_resolve(
+        UrlResolveKind::File { file: &file },
+        UrlResolveKind::Root,
+      ),
+      "../",
+    );
+    // symbol page: `foo/~/Bar.html` -> two levels deep.
+    assert_eq!(
+      href_path_resolve(
+        UrlResolveKind::Symbol {
+          file: &file,
+          symbol: "Bar",
+        },
+        UrlResolveKind::Root,
+      ),
+      "../../",
+    );
+  }
+}