anchors fix

Author: thisisjofrank

orama/generate_orama_index_full.ts

@@ -230,6 +230,25 @@ function buildUrl(relativePath: string, baseUrl?: string): string {
   return `${BASE_URL}${url}`;
 }
 
+/**
+ * Build path from relative path (without base URL)
+ */
+function buildPath(relativePath: string, baseUrl?: string): string {
+  if (baseUrl) {
+    // For API docs, return relative path with baseUrl
+    return `${baseUrl}/${relativePath}`;
+  }
+
+  let path = relativePath.replace(/\.(md|mdx)$/, "");
+  if (path.endsWith("/index")) {
+    path = path.replace(/\/index$/, "/");
+  }
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  return path;
+}
+
 /**
  * Process a single API symbol from reference documentation
  */
@@ -239,11 +258,11 @@ function processApiSymbol(
   apiType: string,
   baseUrl: string,
   packageName: string,
-): OramaDocument | null {
+): OramaDocument[] {
   try {
     // Type guard for symbolData
     if (!symbolData || typeof symbolData !== "object") {
-      return null;
+      return [];
     }
 
     const data = symbolData as Record<string, unknown>;
@@ -255,6 +274,9 @@ function processApiSymbol(
     const htmlHeadCtx = data.html_head_ctx as
       | Record<string, unknown>
       | undefined;
+    const tocCtx = data.toc_ctx as
+      | Record<string, unknown>
+      | undefined;
 
     const symbolName = symbolGroupCtx?.name as string ||
       symbolPath.split(".").pop() || "Unknown";
@@ -315,7 +337,7 @@ function processApiSymbol(
 
     // Skip if no meaningful content
     if (content.length < 20) {
-      return null;
+      return [];
     }
 
     // Determine symbol type
@@ -348,15 +370,20 @@ function processApiSymbol(
       }
     }
 
-    // Build clean URL
-    const cleanPath = symbolPath.replace(/^\.\/~\//, "").replace(/\.json$/, "");
+    // Build clean URL - preserve the ~/ prefix for API paths
+    const cleanPath = symbolPath.replace(/^\.\//, "").replace(/\.json$/, "");
     const url = buildUrl(cleanPath, baseUrl);
+    const path = buildPath(cleanPath, baseUrl);
 
-    return {
+    const documents: OramaDocument[] = [];
+
+    // Create main document for the symbol
+    documents.push({
       id: generateId(cleanPath, apiType),
       title: title.replace(" - Deno documentation", ""),
       content: content.trim(),
       url,
+      path,
       category: `api-${apiType}`,
       section: packageName.toLowerCase(),
       subsection: symbolType,
@@ -370,10 +397,48 @@ function processApiSymbol(
         symbolPath: symbolName,
         packageName,
       },
-    };
+    });
+
+    // Process TOC entries to create anchor documents
+    const documentNavigation = tocCtx?.document_navigation as unknown[] | undefined;
+    if (documentNavigation && Array.isArray(documentNavigation)) {
+      for (const navItem of documentNavigation) {
+        if (navItem && typeof navItem === "object") {
+          const navObj = navItem as Record<string, unknown>;
+          const anchor = navObj.anchor as string | undefined;
+          const navContent = navObj.content as string | undefined;
+          
+          if (anchor && navContent) {
+            // Create a document for this anchor
+            documents.push({
+              id: generateId(`${cleanPath}-${anchor}`, apiType),
+              title: `${symbolName}.${navContent}`,
+              content: `${navContent} ${content.trim()}`,
+              url: `${url}#${anchor}`,
+              path: `${path}#${anchor}`,
+              category: `api-${apiType}`,
+              section: packageName.toLowerCase(),
+              subsection: symbolType,
+              description: `${navContent} - ${symbolType} in the ${packageName} API`,
+              tags: [...tags, "anchor"],
+              headings: [navContent],
+              lastModified: Date.now(),
+              docType: "api-reference",
+              apiInfo: {
+                symbolType,
+                symbolPath: symbolName,
+                packageName,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return documents;
   } catch (error) {
     console.error(`Error processing API symbol ${symbolPath}:`, error);
-    return null;
+    return [];
   }
 }
 
@@ -409,17 +474,17 @@ async function processReferenceDocumentation(): Promise<OramaDocument[]> {
           continue;
         }
 
-        const doc = processApiSymbol(
+        const docs = processApiSymbol(
           symbolPath,
           symbolData,
           refFile.apiType,
           refFile.baseUrl,
           refFile.apiType.charAt(0).toUpperCase() + refFile.apiType.slice(1),
         );
 
-        if (doc) {
-          documents.push(doc);
-          processed++;
+        if (docs && docs.length > 0) {
+          documents.push(...docs);
+          processed += docs.length;
         } else {
           skipped++;
         }
@@ -535,14 +600,16 @@ async function collectMarkdownFiles(): Promise<OramaDocument[]> {
             relativePath,
           );
 
-          // Build URL
+          // Build URL and path
           const url = buildUrl(relativePath);
+          const path = buildPath(relativePath);
 
           files.push({
             id: generateId(relativePath),
             title,
             content: prefixedContent,
             url,
+            path,
             category,
             section,
             subsection: subsection || undefined,

search.client.ts

@@ -469,7 +469,24 @@ class OramaSearch {
   formatUrl(url: string | undefined, hit?: Hit<OramaDocument>): string {
     // First try to use the path field if available (this should be a clean relative path)
     if (hit && hit.document && hit.document.path) {
-      const path = hit.document.path;
+      const path = this.cleanUrl(hit.document.path);
+
+      // Check if the original URL has an anchor that we should preserve
+      if (url && url.includes("#")) {
+        const anchorMatch = url.match(/#[^#]*$/);
+        if (anchorMatch) {
+          const anchor = anchorMatch[0];
+          // Only add anchor if it's not a "jump-to-heading" artifact
+          if (
+            !anchor.includes("jump-to-heading") &&
+            !anchor.includes("Jump-to-heading")
+          ) {
+            const cleanPath = path.startsWith("/") ? path : "/" + path;
+            return cleanPath + anchor;
+          }
+        }
+      }
+
       // If it starts with '/', it's already a root-relative path
       if (path.startsWith("/")) {
         return path;
@@ -503,11 +520,11 @@ class OramaSearch {
     // Clean the URL first
     const cleanedUrl = this.cleanUrl(url);
 
-    // If it's already a full URL, extract just the path part
+    // If it's already a full URL, extract just the path part (including anchor)
     if (cleanedUrl.startsWith("http://") || cleanedUrl.startsWith("https://")) {
       try {
         const urlObj = new URL(cleanedUrl);
-        return urlObj.pathname;
+        return urlObj.pathname + urlObj.hash;
       } catch {
         // If URL parsing fails, fall back to original logic
         return cleanedUrl;
@@ -530,10 +547,13 @@ class OramaSearch {
       .replace(/\s*jump\s+to\s+heading\s*/gi, "")
       .replace(/\s*#jump-to-heading\s*/gi, "")
       .replace(/\s*-jump-to-heading\s*/gi, "")
+      .replace(/#jump-to-heading/gi, "")
+      .replace(/-jump-to-heading/gi, "")
       .trim();
 
-    // Remove any trailing or leading hashes that might be left
-    cleaned = cleaned.replace(/^#+|#+$/g, "");
+    // Remove empty hash fragments or multiple hashes, but preserve legitimate anchors
+    cleaned = cleaned.replace(/#+$/, ""); // Remove trailing empty hashes
+    cleaned = cleaned.replace(/^#+/, ""); // Remove leading hashes only if they're standalone
 
     // If the URL became empty or just whitespace, return the original
     if (!cleaned || cleaned.trim() === "") {