index.js

import {fileURLToPath} from 'url';
import {join} from 'path';
import fs from 'fs';
import {checkLinksInHtml, normalizeHtmlFilePath, loadExternalLinkCache, saveExternalLinkCache} from './check-links.js';
import fastGlob from 'fast-glob';

const LINK_CHECKER_DIR = '.link-checker';
const VERIFIED_LINKS_FILE = 'verified-external-links.tsv';
const BROKEN_LINKS_FILE = 'broken-links.log';

/**
 * Ensures the link checker directory exists and has a .gitignore file
 * that ignores broken-links.log and itself (so the directory only appears
 * in git when verified-external-links.tsv exists).
 */
function ensureLinkCheckerDir(dirPath) {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, {recursive: true});
  }

  const gitignorePath = join(dirPath, '.gitignore');
  if (!fs.existsSync(gitignorePath)) {
    fs.writeFileSync(gitignorePath, `# Auto-generated by astro-broken-link-checker
# Only verified-external-links.tsv should be committed to git
.gitignore
broken-links.log
`, 'utf8');
  }
}

export default function astroBrokenLinksChecker(options = {}) {
  const linkCheckerDir = options.linkCheckerDir || LINK_CHECKER_DIR;
  const logFilePath = join(linkCheckerDir, BROKEN_LINKS_FILE);
  const verifiedLinksPath = join(linkCheckerDir, VERIFIED_LINKS_FILE);
  const brokenLinksMap = new Map(); // Map of brokenLink -> Set of documents
  const checkedLinks = new Map();
  let externalLinkCache = null;

  return {
    name: 'astro-broken-links-checker',
    hooks: {
      'astro:config:setup': async ({config}) => {
        //console.log('config.redirects', config.redirects);
        // save the redirects to the options
        options.astroConfigRedirects = config.redirects;

        // use astro trailingSlash setting, falling back to astro default of 'ignore'
        options.trailingSlash = config.trailingSlash || 'ignore';
      },

      'astro:build:done': async ({dir, logger}) => {
        const astroConfigRedirects = options.astroConfigRedirects;
        //console.log('astroConfigRedirects', astroConfigRedirects);
        const distPath = fileURLToPath(dir);
        const htmlFiles = await fastGlob('**/*.html', {cwd: distPath});
        logger.info(`Checking ${htmlFiles.length} html pages for broken links`);

        // Ensure link checker directory exists with .gitignore
        ensureLinkCheckerDir(linkCheckerDir);

        // Load external link cache if checking external links and caching is enabled
        const cacheExternalLinks = options.cacheExternalLinks !== false;
        if (options.checkExternalLinks && cacheExternalLinks) {
          externalLinkCache = loadExternalLinkCache(verifiedLinksPath);
          const cachedCount = externalLinkCache.size;
          if (cachedCount > 0) {
            logger.info(`Loaded ${cachedCount} verified external links from cache`);
          }
        }

        // start time
        const startTime = Date.now();
        const checkHtmlPromises = htmlFiles.map(async (htmlFile) => {
          const absoluteHtmlFilePath = join(distPath, htmlFile);
          const htmlContent = fs.readFileSync(absoluteHtmlFilePath, 'utf8');
          const baseUrl = normalizeHtmlFilePath(absoluteHtmlFilePath, distPath);
          await checkLinksInHtml(
            htmlContent,
            brokenLinksMap,
            baseUrl,
            absoluteHtmlFilePath, // Document path
            checkedLinks,
            distPath,
            astroConfigRedirects,
            logger,
            options.checkExternalLinks,
            options.trailingSlash,
            externalLinkCache,
          );
        });

        await Promise.all(checkHtmlPromises);

        // Save external link cache if checking external links and caching is enabled
        if (options.checkExternalLinks && cacheExternalLinks && externalLinkCache) {
          saveExternalLinkCache(verifiedLinksPath, externalLinkCache);
          logger.info(`Saved ${externalLinkCache.size} verified external links to cache`);
        }

        logBrokenLinks(brokenLinksMap, logFilePath, logger, linkCheckerDir);

        // end time
        const endTime = Date.now();
        logger.info(`Time to check links: ${endTime - startTime} ms`);

        // stop the build if we have broken links and the option is set
        if (options.throwError && brokenLinksMap.size > 0) {
          throw new Error(`Broken links detected. Check the log file: ${logFilePath}`);
        }
      },
    },
  };
}

function logBrokenLinks(brokenLinksMap, logFilePath, logger, linkCheckerDir) {
  if (brokenLinksMap.size > 0) {
    let logData = '';
    for (const [brokenLink, documentsSet] of brokenLinksMap.entries()) {
      const documents = Array.from(documentsSet);
      logData += `Broken link: ${brokenLink}\n  Found in:\n`;
      for (const doc of documents) {
        logData += `    - ${doc}\n`;
      }
    }
    logData = logData.trim();
    if (logFilePath) {
      // Ensure directory exists with .gitignore
      if (linkCheckerDir) {
        ensureLinkCheckerDir(linkCheckerDir);
      }
      fs.writeFileSync(logFilePath, logData, 'utf8');
      logger.info(`Broken links have been logged to ${logFilePath}`);
      logger.info(logData);
    } else {
      logger.info(logData);
    }
  } else {
    logger.info('No broken links detected.');
    if (fs.existsSync(logFilePath)) {
      logger.info('Removing old log file:', logFilePath);
      fs.rmSync(logFilePath);
    }
  }
}