ci: fix sync-docs workflow

Signed-off-by: Emilien Escalle <emilien.escalle@escemi.com>

Author: neilime

.github/actions/prepare-docs/lib/artifact/artifact-processor.js

@@ -1,7 +1,11 @@
 "use strict";
 
 const path = require("path");
-const { MARKDOWN_EXTENSIONS, STATIC_DIRECTORY } = require("../constants");
+const {
+  MARKDOWN_EXTENSIONS,
+  STATIC_DIRECTORY,
+  STATIC_ASSET_PREFIX,
+} = require("../constants");
 const { iterateFiles } = require("../utils/file-iterator");
 const {
   normalizeToPosix,
@@ -11,7 +15,6 @@ const {
   toSystemPath,
   deriveTitleFromReadmePath,
 } = require("../utils/path-utils");
-const { registerAssetPath } = require("../utils/asset-registry");
 const { MarkdownProcessor } = require("../markdown/markdown-processor");
 
 class ArtifactProcessor {
@@ -62,11 +65,11 @@ class ArtifactProcessor {
       const normalizedSourcePath = normalizeToPosix(relativePath);
       const sanitizedRelativePathRaw = sanitizeRelativePath(relativePath);
       const sanitizedRelativePath = rewriteReadmeToIndex(
-        sanitizedRelativePathRaw,
+        sanitizedRelativePathRaw
       );
       const renamedFromReadme = didRewriteReadme(
         sanitizedRelativePathRaw,
-        sanitizedRelativePath,
+        sanitizedRelativePath
       );
       const derivedTitle = renamedFromReadme
         ? deriveTitleFromReadmePath({
@@ -80,7 +83,7 @@ class ArtifactProcessor {
       }
 
       const isMarkdown = MARKDOWN_EXTENSIONS.has(
-        path.extname(sanitizedRelativePath).toLowerCase(),
+        path.extname(sanitizedRelativePath).toLowerCase()
       );
 
       let targetRelativePath;
@@ -93,11 +96,11 @@ class ArtifactProcessor {
       } else {
         assetRegistration = registerAssetPath(
           this.assetMap,
-          sanitizedRelativePath,
+          sanitizedRelativePath
         );
         targetRelativePath = path.posix.join(
           STATIC_DIRECTORY,
-          assetRegistration.storageRelativePath,
+          assetRegistration.storageRelativePath
         );
         destination = toSystemPath(this.outputPath, targetRelativePath);
       }
@@ -119,7 +122,7 @@ class ArtifactProcessor {
         });
       } else {
         this.core.info(
-          `  Copied asset: ${targetRelativePath} (public ${assetRegistration.publicPath})`,
+          `  Copied asset: ${targetRelativePath} (public ${assetRegistration.publicPath})`
         );
       }
     }
@@ -142,6 +145,27 @@ class ArtifactProcessor {
   }
 }
 
+function registerAssetPath(assetMap, assetPath) {
+  const key = normalizeToPosix(assetPath);
+  const storageRelativePath = path.posix.join(STATIC_ASSET_PREFIX, key);
+  const publicPath = `/${storageRelativePath}`.replace(/\/+/g, "/");
+
+  if (!assetMap.has(key)) {
+    assetMap.set(key, {
+      storageRelativePath,
+      publicPath,
+    });
+  }
+
+  const registration = assetMap.get(key);
+
+  return {
+    key,
+    storageRelativePath: registration.storageRelativePath,
+    publicPath: registration.publicPath,
+  };
+}
+
 module.exports = {
   ArtifactProcessor,
 };

.github/actions/prepare-docs/lib/documentation-preparer.js

@@ -5,7 +5,6 @@ const {
   ensureArtifactDirectory,
   prepareOutputDirectory,
 } = require("./utils/fs-utils");
-const { parseRepositorySlug } = require("./utils/repository-utils");
 const { resolveSourceBranch } = require("./services/source-branch-resolver");
 const { ArtifactProcessor } = require("./artifact/artifact-processor");
 const { ensureIndexPage } = require("./artifact/index-page-writer");
@@ -29,7 +28,7 @@ class DocumentationPreparer {
     ensureArtifactDirectory(this.artifactPath);
 
     this.core.info(
-      `Preparing documentation bundle for ${this.sourceRepository}`,
+      `Preparing documentation bundle for ${this.sourceRepository}`
     );
 
     await prepareOutputDirectory(this.outputPath, this.io);
@@ -66,7 +65,7 @@ class DocumentationPreparer {
     });
 
     this.core.info(
-      `Documentation bundle prepared with ${processedFiles.length} files.`,
+      `Documentation bundle prepared with ${processedFiles.length} files.`
     );
 
     return {
@@ -76,6 +75,15 @@ class DocumentationPreparer {
   }
 }
 
+function parseRepositorySlug(repository) {
+  const [owner, name] = (repository || "").split("/");
+  if (!owner || !name) {
+    throw new Error(`Invalid repository slug "${repository}".`);
+  }
+
+  return { owner, name };
+}
+
 module.exports = {
   DocumentationPreparer,
 };

.github/actions/prepare-docs/lib/markdown/markdown-normalizer.js

@@ -1,17 +1,19 @@
 "use strict";
 
-const {
-  splitLinkPathAndSuffix,
-  sanitizeLinkPath,
-} = require("../utils/path-utils");
-const { resolveAssetPublicPath } = require("../utils/asset-registry");
+const { AssetRewriter } = require("../services/asset-rewriter");
 
 function normalizeMarkdownBody(content, options = {}) {
   if (!content) {
     return content;
   }
 
-  return rewriteLocalLinks(convertAngleBracketLinks(content), options);
+  const assetRewriter = new AssetRewriter(options);
+  const convertedLinks = convertAngleBracketLinks(content);
+  const rewrittenMarkdownLinks = rewriteLocalLinks(
+    convertedLinks,
+    assetRewriter
+  );
+  return rewriteHtmlAttributes(rewrittenMarkdownLinks, assetRewriter);
 }
 
 function convertAngleBracketLinks(text) {
@@ -25,11 +27,11 @@ function convertAngleBracketLinks(text) {
       const isEmail = raw.includes("@");
       const href = isEmail ? `mailto:${raw}` : raw;
       return `[${raw}](${href})`;
-    },
+    }
   );
 }
 
-function rewriteLocalLinks(text, options = {}) {
+function rewriteLocalLinks(text, assetRewriter) {
   if (!text) {
     return text;
   }
@@ -109,7 +111,7 @@ function rewriteLocalLinks(text, options = {}) {
     }
 
     const target = text.slice(afterBracket + 1, parenEnd);
-    const rewrittenTarget = rewriteLinkTarget(target, options);
+    const rewrittenTarget = rewriteLinkTarget(target, assetRewriter);
 
     result += text.slice(bracketIndex, afterBracket + 1);
     result += rewrittenTarget;
@@ -118,22 +120,22 @@ function rewriteLocalLinks(text, options = {}) {
     index = parenEnd + 1;
   }
 
-  return rewriteReferenceLinks(result, options);
+  return rewriteReferenceLinks(result, assetRewriter);
 }
 
-function rewriteReferenceLinks(text, options = {}) {
+function rewriteReferenceLinks(text, assetRewriter) {
   const referencePattern = /^(\s*\[[^\]]+\]:\s*)(.+)$/gm;
 
   return text.replace(referencePattern, (match, prefix, target) => {
-    const rewritten = rewriteLinkTarget(target, options);
+    const rewritten = rewriteLinkTarget(target, assetRewriter);
     if (rewritten === target) {
       return match;
     }
     return `${prefix}${rewritten}`;
   });
 }
 
-function rewriteLinkTarget(rawTarget, options = {}) {
+function rewriteLinkTarget(rawTarget, assetRewriter) {
   if (!rawTarget) {
     return rawTarget;
   }
@@ -167,48 +169,55 @@ function rewriteLinkTarget(rawTarget, options = {}) {
     }
   }
 
-  if (!urlPart || isExternalLink(urlPart)) {
-    return rawTarget;
-  }
+  const { value, changed } = assetRewriter.rewrite(urlPart);
 
-  const { path: targetPath, suffix } = splitLinkPathAndSuffix(urlPart);
-  if (!targetPath) {
+  if (!changed) {
     return rawTarget;
   }
 
-  const sanitizedPath = sanitizeLinkPath(targetPath);
-  const assetPublicPath = resolveAssetPublicPath({
-    assetMap: options.assetMap,
-    docRelativePath: options.docRelativePath,
-    targetPath: sanitizedPath,
-    docsPath: options.docsPath,
-    staticPath: options.staticPath,
-  });
-  const rewrittenPath = assetPublicPath || sanitizedPath;
-  const rebuiltTarget = `${rewrittenPath}${suffix}`;
+  return `${leadingWhitespace}${value}${trailingTitle}`;
+}
 
-  if (rebuiltTarget === urlPart) {
-    return rawTarget;
+function rewriteHtmlAttributes(text, assetRewriter) {
+  if (!text) {
+    return text;
   }
 
-  return `${leadingWhitespace}${rebuiltTarget}${trailingTitle}`;
+  const attributePattern = /(<[^>]+?\s)(src|href)(\s*=\s*)(["'])([^"']+?)\4/gi;
+
+  return text.replace(
+    attributePattern,
+    (match, prefix, attribute, equalsPart, quote, value) => {
+      const rewrittenValue = rewriteHtmlAttributeValue(value, assetRewriter);
+      if (rewrittenValue === value) {
+        return match;
+      }
+
+      return `${prefix}${attribute}${equalsPart}${quote}${rewrittenValue}${quote}`;
+    }
+  );
 }
 
-function isExternalLink(target) {
-  const trimmed = target.trim();
-  if (!trimmed) {
-    return true;
+function rewriteHtmlAttributeValue(rawValue, assetRewriter) {
+  if (!rawValue) {
+    return rawValue;
   }
 
-  if (trimmed.startsWith("#")) {
-    return true;
+  const leadingWhitespace = rawValue.match(/^\s+/)?.[0] || "";
+  const trailingWhitespace = rawValue.match(/\s+$/)?.[0] || "";
+  const coreValue = rawValue.trim();
+
+  if (!coreValue) {
+    return rawValue;
   }
 
-  if (trimmed.startsWith("//")) {
-    return true;
+  const { value, changed } = assetRewriter.rewrite(coreValue);
+
+  if (!changed) {
+    return rawValue;
   }
 
-  return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed);
+  return `${leadingWhitespace}${value}${trailingWhitespace}`;
 }
 
 module.exports = {