starlight-cannoli-plugins 2.3.4 → 2.4.0

package/dist/chunk-IFQMZ5HP.js

@@ -0,0 +1,130 @@
+// src/plugins/astro-normalize-paths/index.ts
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { glob } from "glob";
+import { dirname, relative, resolve } from "path";
+import { JSDOM } from "jsdom";
+var LINK_ELEMENT_TO_ACCESSOR_MAP = {
+  img: "src",
+  a: "href"
+};
+var LinkElement = class {
+  _element;
+  _accessor;
+  _href;
+  constructor(element) {
+    this._element = element;
+    this._accessor = this.getAccessorName();
+    this._href = this.extractHref(element);
+  }
+  get href() {
+    return this._href;
+  }
+  set href(newHref) {
+    this._href = newHref;
+    this._element.setAttribute(this._accessor, newHref);
+  }
+  getAccessorName() {
+    const tagName = this._element.tagName.toLowerCase();
+    return LINK_ELEMENT_TO_ACCESSOR_MAP[tagName];
+  }
+  extractHref(element) {
+    return element.getAttribute(this._accessor) ?? "";
+  }
+};
+var SRC_CONTENT_ROOT = "src/content/docs/";
+function astroNormalizePaths() {
+  return {
+    name: "astro-normalize-paths",
+    hooks: {
+      "astro:build:done": async ({ dir }) => {
+        const htmlFiles = await glob(`${dir.pathname}/**/*.html`);
+        const distRoot = dir.pathname.replace(/\/+$/, "");
+        await Promise.all(
+          htmlFiles.map(async (htmlFilePath) => {
+            if (!htmlFilePath.endsWith("/index.html")) return;
+            const dom = new JSDOM(await readFile(htmlFilePath, "utf-8"));
+            const document = dom.window.document;
+            let hasHtmlContentChanged = false;
+            const sourceFilePath = resolveSourceFile(htmlFilePath, distRoot);
+            const linkElements = getLinks(document);
+            for (const link of linkElements) {
+              if (!isRelativePath(link.href)) continue;
+              const normalizedLinkPath = normalizeAssetPath(
+                link.href,
+                sourceFilePath
+              );
+              link.href = normalizedLinkPath;
+              hasHtmlContentChanged = true;
+            }
+            if (hasHtmlContentChanged) {
+              await writeFile(htmlFilePath, dom.serialize(), "utf-8");
+            }
+          })
+        );
+      }
+    }
+  };
+}
+function getLinks(document) {
+  const selector = Object.keys(LINK_ELEMENT_TO_ACCESSOR_MAP).join(", ");
+  const elements = document.querySelectorAll(selector);
+  return Array.from(elements).map((el) => new LinkElement(el));
+}
+function resolveSourceFile(htmlFilePath, distRoot) {
+  const normalizedDistDir = distRoot.replace(/\/+$/, "");
+  const srcDir = SRC_CONTENT_ROOT.replace(/\/+$/, "");
+  const relativeHtmlPath = htmlFilePath.slice(normalizedDistDir.length).replace(/^\/+/, "");
+  if (relativeHtmlPath !== "index.html" && !relativeHtmlPath.endsWith("/index.html")) {
+    throw new Error(
+      `resolveSourceFile: expected a path ending in index.html, got: ${htmlFilePath}`
+    );
+  }
+  const relativeDir = relativeHtmlPath === "index.html" ? "" : relativeHtmlPath.slice(0, -"/index.html".length);
+  const baseDir = relativeDir ? `${srcDir}/${relativeDir}` : srcDir;
+  const candidates = [`${baseDir}/index.md`, `${baseDir}/index.mdx`];
+  if (relativeDir) {
+    candidates.push(
+      `${srcDir}/${relativeDir}.md`,
+      `${srcDir}/${relativeDir}.mdx`
+    );
+  }
+  const matches = candidates.filter(existsSync);
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) {
+    throw new Error(
+      `[astro-normalize-paths] Could not find a source file for ${htmlFilePath}. Expected one of: ${candidates.join(", ")}`
+    );
+  }
+  throw new Error(
+    `[astro-normalize-paths] Ambiguous source files for ${htmlFilePath}: ${matches.join(", ")}. Astro can compile both a directory index file (e.g. reference/schemas/index.md) and a same-named file one level up (e.g. reference/schemas.md) into the same output path. Remove one of the conflicting files to resolve this.`
+  );
+}
+function normalizeAssetPath(relLinkHref, sourceFilePath) {
+  let suffix = "";
+  let href = relLinkHref;
+  const hashIdx = href.indexOf("#");
+  if (hashIdx !== -1) {
+    suffix = href.slice(hashIdx);
+    href = href.slice(0, hashIdx);
+  }
+  const queryIdx = href.indexOf("?");
+  if (queryIdx !== -1) {
+    suffix = href.slice(queryIdx) + suffix;
+    href = href.slice(0, queryIdx);
+  }
+  const absoluteLinkedPath = resolve(dirname(sourceFilePath), href);
+  const relToRoot = relative(process.cwd(), absoluteLinkedPath);
+  const srcContentRoot = SRC_CONTENT_ROOT.replace(/\/+$/, "");
+  const relToContentRoot = relToRoot.startsWith(srcContentRoot) ? relToRoot.slice(srcContentRoot.length).replace(/^\/+/, "") : relToRoot;
+  return "/" + relToContentRoot.replace(/\\/g, "/") + suffix;
+}
+function isRelativePath(path) {
+  return !path.startsWith("/") && !path.startsWith("http://") && !path.startsWith("https://") && !path.startsWith("data:") && !path.startsWith("#") && !path.startsWith("mailto:");
+}
+var astro_normalize_paths_default = astroNormalizePaths;
+
+export {
+  astroNormalizePaths,
+  astro_normalize_paths_default
+};

package/dist/index.js

@@ -9,7 +9,7 @@ import {
 } from "./chunk-XVMRLEQM.js";
 import {
   astroNormalizePaths
-} from "./chunk-AZPHBHBE.js";
+} from "./chunk-IFQMZ5HP.js";
 import {
   syncDocsToPublic
 } from "./chunk-WZNJ5VFU.js";

package/dist/plugins/astro-normalize-paths.d.ts

@@ -1,11 +1,11 @@
 import { AstroIntegration } from 'astro';
 
 /**
- * Astro integration that normalizes img src and anchor href attributes to absolute paths in HTML files after build.
- * This processes resources in Starlight docs that aren't handled by the rehype plugin.
+ * Astro integration that rewrites relative link hrefs in built HTML files to absolute site paths.
  *
- * Handles the case where Astro converts markdown files into index.html files in subdirectories,
- * which changes the relative path structure.
+ * Relative links break when web hosts differ in whether they append a trailing slash to URLs.
+ * This integration runs after the build, resolves every relative href against the original
+ * source file's location, and replaces it with an absolute path so behaviour is host-independent.
  */
 declare function astroNormalizePaths(): AstroIntegration;
 

package/dist/plugins/astro-normalize-paths.js

@@ -1,7 +1,7 @@
 import {
   astroNormalizePaths,
   astro_normalize_paths_default
-} from "../chunk-AZPHBHBE.js";
+} from "../chunk-IFQMZ5HP.js";
 import "../chunk-QGM4M3NI.js";
 export {
   astroNormalizePaths,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "starlight-cannoli-plugins",
   "type": "module",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "description": "Starlight plugins for automatic sidebar generation and link validation",
   "license": "ISC",
   "main": "./dist/index.js",
@@ -72,6 +72,7 @@
   "dependencies": {
     "eslint-cannoli-plugins": "^1.0.13",
     "glob": "^11.0.0",
+    "jsdom": "^29.0.2",
     "minimatch": "^9.0.0",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.4.0"
@@ -100,6 +101,7 @@
     "@hpcc-js/wasm": "^2.33.1",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/hast": "^3.0.0",
+    "@types/jsdom": "^28.0.1",
     "@typescript-eslint/eslint-plugin": "^8.56.1",
     "@typescript-eslint/parser": "^8.56.1",
     "astro": "^5.6.1",

package/dist/chunk-AZPHBHBE.js

@@ -1,71 +0,0 @@
-// src/plugins/astro-normalize-paths.ts
-import { existsSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import { glob } from "glob";
-import { dirname, resolve } from "path";
-function astroNormalizePaths() {
-  return {
-    name: "astro-normalize-paths",
-    hooks: {
-      "astro:build:done": async ({ dir }) => {
-        const htmlFiles = await glob(`${dir.pathname}/**/*.html`);
-        await Promise.all(
-          htmlFiles.map(async (htmlFile) => {
-            let content = await readFile(htmlFile, "utf-8");
-            const originalContent = content;
-            const imgRegex = /<img([^>]*?)src=["']([^"']+)["']/g;
-            let match;
-            while ((match = imgRegex.exec(content)) !== null) {
-              const attrs = match[1];
-              const src = match[2];
-              const normalized = normalizeAssetPath(src, htmlFile, dir.pathname);
-              if (normalized && src !== normalized) {
-                console.log(`[astro-normalize-paths] Img path resolution:`);
-                console.log(`  Original: ${src}`);
-                console.log(`  HTML file: ${htmlFile}`);
-                console.log(`  Normalized: ${normalized}`);
-                content = content.replace(`<img${attrs}src="${src}"`, `<img${attrs}src="${normalized}"`);
-              }
-            }
-            const anchorRegex = /<a([^>]*?)href=["']([^"']+)["']/g;
-            while ((match = anchorRegex.exec(content)) !== null) {
-              const attrs = match[1];
-              const href = match[2];
-              const normalized = normalizeAssetPath(href, htmlFile, dir.pathname);
-              if (normalized && href !== normalized) {
-                content = content.replace(`<a${attrs}href="${href}"`, `<a${attrs}href="${normalized}"`);
-              }
-            }
-            if (content !== originalContent) {
-              await writeFile(htmlFile, content, "utf-8");
-            }
-          })
-        );
-      }
-    }
-  };
-}
-function normalizeAssetPath(path, htmlFile, siteRootPath) {
-  if (path.startsWith("http") || path.startsWith("data:") || path.startsWith("/")) {
-    return null;
-  }
-  const htmlDir = dirname(htmlFile);
-  const resolvedPath = resolve(htmlDir, path);
-  const siteRoot = resolve(siteRootPath);
-  let absolutePath = resolvedPath.slice(siteRoot.length).replace(/\\/g, "/");
-  if (!existsSync(resolvedPath)) {
-    const parentDir = dirname(htmlDir);
-    const alternativePath = resolve(parentDir, path);
-    if (existsSync(alternativePath)) {
-      absolutePath = alternativePath.slice(siteRoot.length).replace(/\\/g, "/");
-    }
-  }
-  const finalPath = "/" + absolutePath.replace(/^\/+/, "");
-  return finalPath;
-}
-var astro_normalize_paths_default = astroNormalizePaths;
-
-export {
-  astroNormalizePaths,
-  astro_normalize_paths_default
-};