nuxt-link-checker 2.0.0-beta.5 → 2.0.0-beta.7

package/README.md

@@ -34,127 +34,38 @@ Find and magically fix links that may be negatively effecting your Nuxt sites SE
 
 ## Features
 
-- ✅ Discover broken links - 404s and internal redirects
-- 🚩 Warnings for bad practice links - absolute instead of relative and wrong trailing slash
-- 🕵️ Fail on build if broken links are found (optional)
+- ✅ 7 SEO focused link inspections (more coming soon)
+- ✨ See live inspections right in your Nuxt App
+- 🧙 Magically fix them in Nuxt Dev Tools
+- 🚩 Generate reports on build (html, markdown)
 
-## Install
 
-```bash
-npm install --save-dev nuxt-link-checker
-
-# Using yarn
-yarn add --dev nuxt-link-checker
-```
-
-## Setup
-
-_nuxt.config.ts_
-
-```ts
-export default defineNuxtConfig({
-  modules: [
-    'nuxt-link-checker',
-  ],
-})
-```
-
-To have routes scanned for broken links automatically, they need to be pre-rendered by Nitro.
-
-```ts
-export default defineNuxtConfig({
-  nitro: {
-    prerender: {
-      crawlLinks: true,
-      routes: [
-        '/',
-        // any URLs that can't be discovered by crawler
-        '/my-hidden-url'
-      ]
-    }
-  }
-})
-```  
-
-### Set host (optional)
-
-You'll need to provide the host of your site so that the crawler can resolve absolute URLs that may be internal.
-
-```ts
-export default defineNuxtConfig({
-  // Recommended
-  runtimeConfig: {
-    public: {
-      siteUrl: process.env.NUXT_PUBLIC_SITE_URL || 'https://example.com',
-    }
-  },
-  // OR
-  linkChecker: {
-    host: 'https://example.com',
-  },
-})
-```
-
-### Exclude URLs from throwing errors
+## Installation
 
-You can exclude URLs from throwing errors by adding them to the `exclude` array.
+1. Install `nuxt-link-checker` dependency to your project:
 
-For example, if you have an `/admin` route that is a separate application, you can ignore all `/admin` links with:
 
-```ts
-export default defineNuxtConfig({
-  linkChecker: {
-    exclude: [
-      '/admin/**'
-    ],
-  },
-})
+```bash
+#
+yarn add -D nuxt-link-checker
+#
+npm install -D nuxt-link-checker
+#
+pnpm i -D nuxt-link-checker
 ```
 
-### Disable errors on broken links
 
-You can disable errors on broken links by setting `failOn404` to `false`.
+2. Add it to your `modules` section in your `nuxt.config`:
 
 ```ts
 export default defineNuxtConfig({
-  linkChecker: {
-    failOn404: false,
-  },
+  modules: ['nuxt-link-checker']
 })
 ```
 
-## Module Config
-
-### `failOn404`
-
-- Type: `boolean`
-- Default: `true`
-
-If set to `true`, the build will fail if any broken links are found.
+# Documentation
 
-### `exclude`
-
-- Type: `string[]`
-- Default: `[]`
-
-An array of URLs to exclude from the check. 
-
-This can be useful if you have a route that is not pre-rendered, but you know it will be valid.
-
-### `host`
-
-- Type: `string`
-- Default: `runtimeConfig.public.siteUrl || localhost`
-- Required: `false`
-
-The host of your site. This is required to validate absolute URLs which may be internal.
-
-### `trailingSlash`
-
-- Type: `boolean`
-- Default: `false`
-
-Whether internal links should have a trailing slash or not.
+[📖 Read the full documentation](https://nuxtseo.com/nuxt-link-checker/getting-started/installation) for more information.
 
 ## Sponsors
 
@@ -164,7 +75,6 @@ Whether internal links should have a trailing slash or not.
   </a>
 </p>
 
-
 ## License
 
 MIT License © 2023-PRESENT [Harlan Wilton](https://github.com/harlan-zw)

package/dist/module.d.ts

@@ -1,14 +1,83 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { FetchResponse } from 'ofetch';
+import { SiteConfig } from 'nuxt-site-config-kit';
+import Fuse from 'fuse.js';
+import { ParsedURL } from 'ufo';
+
+interface Rule {
+    test(ctx: RuleTestContext): void;
+}
+interface RuleTestContext {
+    link: string;
+    url: ParsedURL;
+    ids: string[];
+    fromPath: string;
+    response: FetchResponse<any>;
+    siteConfig: SiteConfig;
+    pageSearch?: Fuse<string>;
+    report: (report: RuleReport) => void;
+    skipInspections?: string[];
+}
+interface RuleReport {
+    name: string;
+    scope: 'error' | 'warning';
+    message: string;
+    fix?: string;
+    fixDescription?: string;
+    tip?: string;
+    canRetry?: boolean;
+}
+
+declare const DefaultInspections: {
+    readonly 'missing-hash': Rule;
+    readonly 'no-error-response': Rule;
+    readonly 'no-baseless': Rule;
+    readonly 'no-javascript': Rule;
+    readonly 'trailing-slash': Rule;
+    readonly 'absolute-site-urls': Rule;
+    readonly redirects: Rule;
+};
 
 interface ModuleOptions {
     /**
      * Whether the build should fail when a 404 is encountered.
      */
-    failOn404: boolean;
+    failOnError: boolean;
+    /**
+     * Skip specific inspections from running.
+     */
+    skipInspections: (Partial<keyof typeof DefaultInspections>)[];
+    /**
+     * The timeout for fetching a URL.
+     *
+     * @default 5000
+     */
+    fetchTimeout: number;
+    /**
+     * Links to ignore when running inspections.
+     */
+    excludeLinks: string[];
+    /**
+     * Generate a report when using nuxt build` or `nuxt generate`.
+     */
+    report?: {
+        /**
+         * Whether to output a HTML report.
+         */
+        html?: boolean;
+        /**
+         * Whether to output a JSON report.
+         */
+        markdown?: boolean;
+    };
+    /**
+     * Whether to show live inspections in your Nuxt app.
+     */
+    showLiveInspections: boolean;
     /**
-     * Paths to ignore when checking links.
+     * Whether to run the module on `nuxt build` or `nuxt generate`.
      */
-    exclude: string[];
+    runOnBuild: boolean;
     /**
      * Whether the module is enabled.
      *

package/dist/module.json

@@ -5,5 +5,5 @@
     "bridge": false
   },
   "configKey": "linkChecker",
-  "version": "2.0.0-beta.5"
+  "version": "2.0.0-beta.7"
 }

package/dist/module.mjs

@@ -1,49 +1,18 @@
 import { useNuxt, extendPages, defineNuxtModule, useLogger, createResolver, addPlugin, addServerHandler, addServerPlugin, hasNuxtModule } from '@nuxt/kit';
-import { installNuxtSiteConfig, updateSiteConfig } from 'nuxt-site-config-kit';
+import { useSiteConfig, installNuxtSiteConfig, updateSiteConfig } from 'nuxt-site-config-kit';
+import fs, { readFile, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
-import { parseURL, hasProtocol, joinURL } from 'ufo';
+import Fuse from 'fuse.js';
+import { resolve } from 'pathe';
 import { load } from 'cheerio';
 import { toRouteMatcher, createRouter } from 'radix3';
+import { parseURL, joinURL } from 'ufo';
+import { fixSlashes } from 'site-config-stack';
 import { existsSync } from 'node:fs';
-import { readFile, writeFile } from 'node:fs/promises';
 import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 import { diffLines, diffArrays } from 'diff';
 import MagicString from 'magic-string';
 
-const linkMap = {};
-const EXT_REGEX = /\.[\da-z]+$/;
-const allowedExtensions = /* @__PURE__ */ new Set(["", ".json"]);
-function getExtension(path) {
-  return (path.match(EXT_REGEX) || [])[0] || "";
-}
-function extractLinks(html, from, { host, trailingSlash }) {
-  const links = [];
-  const hostname = parseURL(host).host;
-  const $ = load(html);
-  $("body [href]").each((i, el) => {
-    const href = $(el).attr("href");
-    if (!href)
-      return;
-    const url = parseURL(href);
-    if (hasProtocol(href) && !href.startsWith("/") && url.host !== hostname)
-      return;
-    if (href.startsWith("#"))
-      return;
-    if (el.tagName === "link" && el.attribs.rel === "canonical")
-      return;
-    if (!allowedExtensions.has(getExtension(href)))
-      return;
-    links.push({
-      pathname: url.pathname || "/",
-      url,
-      badAbsolute: Boolean(hostname) && hostname === url.host,
-      badTrailingSlash: url.pathname !== "/" && !url.pathname.split("/").at(-1).includes(".") && (trailingSlash && !url.pathname.endsWith("/") || !trailingSlash && url.pathname.endsWith("/")),
-      element: $.html(el) || ""
-    });
-  });
-  return links;
-}
-
 function createFilter(options = {}) {
   const include = options.include || [];
   const exclude = options.exclude || [];
@@ -71,65 +40,365 @@ function createFilter(options = {}) {
   };
 }
 
-const invalidStatusCodes = [404, 302, 301, 307, 303];
+function defineRule(rule) {
+  return rule;
+}
+function isInvalidLinkProtocol(link) {
+  return link.startsWith("javascript:") || link.startsWith("blob:") || link.startsWith("data:");
+}
+
+function RuleTrailingSlash() {
+  return defineRule({
+    test({ report, link, siteConfig }) {
+      if (!link.startsWith("/") && !link.startsWith(siteConfig.url))
+        return;
+      const $url = parseURL(link);
+      if ($url.pathname === "/")
+        return;
+      const fix = fixSlashes(siteConfig.trailingSlash, link);
+      if (!$url.pathname.endsWith("/") && siteConfig.trailingSlash) {
+        report({
+          name: "trailing-slash",
+          scope: "warning",
+          message: "Should have a trailing slash.",
+          tip: "Incorrect trailing slashes can cause duplicate pages in search engines and waste crawl budget.",
+          fix,
+          fixDescription: "Add trailing slash."
+        });
+      } else if ($url.pathname.endsWith("/") && !siteConfig.trailingSlash) {
+        report({
+          name: "trailing-slash",
+          scope: "warning",
+          message: "Should not have a trailing slash.",
+          tip: "Incorrect trailing slashes can cause duplicate pages in search engines and waste crawl budget.",
+          fix,
+          fixDescription: "Removing trailing slash."
+        });
+      }
+    }
+  });
+}
+
+function RuleMissingHash() {
+  return defineRule({
+    test({ link, report, ids, fromPath }) {
+      const [path, hash] = link.split("#");
+      if (!link.includes("#") || fixSlashes(false, path) !== fromPath)
+        return;
+      if (ids.includes(hash))
+        return;
+      const fuse = new Fuse(ids, {
+        threshold: 0.6
+      });
+      const fixedHash = fuse.search(hash.replace("#", ""))?.[0]?.item;
+      const payload = {
+        name: "missing-hash",
+        scope: "error",
+        message: `No element with id "${hash}" found.`
+      };
+      if (fixedHash) {
+        payload.fix = `${link.split("#")[0]}#${fixedHash}`;
+        payload.fixDescription = `Did you mean ${payload.fix}?`;
+      }
+      report(payload);
+    }
+  });
+}
+
+function RuleNoBaseLess() {
+  return defineRule({
+    test({ link, fromPath, report }) {
+      if (link.startsWith("/") || link.startsWith("http") || isInvalidLinkProtocol(link) || link.startsWith("#"))
+        return;
+      report({
+        name: "no-baseless",
+        scope: "warning",
+        message: "Should not have a base.",
+        fix: `${joinURL(fromPath, link)}`,
+        fixDescription: `Add base ${fromPath}.`
+      });
+    }
+  });
+}
+
+function RuleNoJavascript() {
+  return defineRule({
+    test({ link, report }) {
+      if (link.startsWith("javascript:")) {
+        report({
+          name: "no-javascript",
+          scope: "error",
+          tip: 'Using a <button type="button"> instead as a better practice.',
+          message: "Should not use JavaScript"
+        });
+      }
+    }
+  });
+}
+
+function RuleAbsoluteSiteUrls() {
+  return defineRule({
+    test({ report, link, siteConfig }) {
+      if (!link.startsWith(siteConfig.url))
+        return;
+      const $url = parseURL(link);
+      report({
+        name: "absolute-site-urls",
+        scope: "warning",
+        message: "Internal links should be relative.",
+        tip: "Using internal links that start with / is recommended to avoid issues when deploying your site to different domain names",
+        fix: $url.pathname,
+        fixDescription: `Remove ${siteConfig.url}.`
+      });
+    }
+  });
+}
+
+function RuleRedirects() {
+  return defineRule({
+    test({ report, response }) {
+      if (response.status !== 301 && response.status !== 302)
+        return;
+      const payload = {
+        name: "redirects",
+        scope: "warning",
+        message: "Should not redirect.",
+        tip: "Redirects use up your crawl budget and increase loading times, it's recommended to avoid them when possible."
+      };
+      const fix = typeof response.headers?.get === "function" ? response.headers.get("location") : response.headers?.location || false;
+      if (fix) {
+        payload.fix = fix;
+        payload.fixDescription = `Set to redirect URL ${fix}.`;
+      }
+      report(payload);
+    }
+  });
+}
+
+function RuleNoErrorResponse() {
+  return defineRule({
+    test({ link, response, report, pageSearch }) {
+      if (response.status.toString().startsWith("2") || response.status.toString().startsWith("3") || isInvalidLinkProtocol(link) || link.startsWith("#"))
+        return;
+      const payload = {
+        name: "no-error-response",
+        scope: "error",
+        message: `Should not respond with ${response.status} ${response.statusText}.`
+      };
+      if (link.startsWith("/") && pageSearch) {
+        const fix = pageSearch.search(link)?.[0]?.item;
+        if (fix && fix !== link) {
+          payload.fix = fix;
+          payload.fixDescription = `Did you mean ${fix}?`;
+        }
+      } else {
+        payload.canRetry = true;
+      }
+      report(payload);
+    }
+  });
+}
+
+const DefaultInspections = {
+  "missing-hash": RuleMissingHash(),
+  "no-error-response": RuleNoErrorResponse(),
+  "no-baseless": RuleNoBaseLess(),
+  "no-javascript": RuleNoJavascript(),
+  "trailing-slash": RuleTrailingSlash(),
+  "absolute-site-urls": RuleAbsoluteSiteUrls(),
+  "redirects": RuleRedirects()
+};
+function inspect(ctx, rules = DefaultInspections) {
+  const res = { error: [], warning: [], fix: ctx.link, link: ctx.link };
+  let link = ctx.link;
+  const url = parseURL(link);
+  if (!url.pathname && !url.protocol && !url.host && !link.startsWith("javascript:")) {
+    res.error.push({
+      name: "invalid-url",
+      scope: "error",
+      message: `Invalid URL: ${link}`
+    });
+    return res;
+  }
+  const validInspections = Object.entries(rules).filter(([name]) => !ctx.skipInspections || !ctx.skipInspections.includes(name)).map(([, rule]) => rule);
+  for (const rule of validInspections) {
+    rule.test({
+      ...ctx,
+      link,
+      url,
+      report(obj) {
+        res[obj.scope].push(obj);
+        if (obj.fix)
+          link = obj.fix;
+      }
+    });
+  }
+  res.passes = !res.error?.length && !res.warning?.length;
+  res.fix = link;
+  return res;
+}
+
+async function crawlFetch(link, options = {}) {
+  const fetch = options.fetch || globalThis.fetch;
+  const timeout = options.timeout || 5e3;
+  const timeoutController = new AbortController();
+  const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
+  return await fetch(link, {
+    method: "HEAD",
+    signal: timeoutController.signal,
+    headers: {
+      "user-agent": "Nuxt Link Checker"
+    }
+  }).catch(() => ({ status: 404, statusText: "Not Found", headers: {} })).finally(() => clearTimeout(abortRequestTimeout));
+}
+
+const responses = {};
+const linkMap = {};
+function extractPayload(html) {
+  const $ = load(html);
+  const ids = $("#__nuxt [id]").map((i, el) => $(el).attr("id")).get();
+  const links = $("#__nuxt a[href]").map((i, el) => $(el).attr("href")).get();
+  return { ids, links };
+}
+async function getLinkResponse(link, timeout) {
+  const response = responses[link];
+  if (!response) {
+    responses[link] = crawlFetch(link, { timeout });
+  }
+  return responses[link];
+}
 function prerender(config, nuxt = useNuxt()) {
   const urlFilter = createFilter({
-    exclude: config.exclude
+    exclude: config.excludeLinks
   });
   nuxt.hooks.hook("nitro:init", async (nitro) => {
-    const invalidRoutes = {};
+    const siteConfig = useSiteConfig();
     nitro.hooks.hook("prerender:generate", async (ctx) => {
-      if (ctx.contents && ctx.fileName?.endsWith(".html"))
-        linkMap[ctx.route] = extractLinks(ctx.contents, ctx.route, config);
-      if (ctx.error?.statusCode && invalidStatusCodes.includes(Number(ctx.error?.statusCode)))
-        invalidRoutes[ctx.route] = ctx.error.statusCode;
+      if (ctx.contents && !ctx.error && ctx.fileName?.endsWith(".html") && !ctx.route.endsWith(".html") && urlFilter(ctx.route)) {
+        linkMap[ctx.route] = extractPayload(ctx.contents);
+        linkMap[ctx.route].links.forEach((link) => {
+          getLinkResponse(link, config.fetchTimeout);
+        });
+      }
+      responses[ctx.route] = Promise.resolve({ status: Number(ctx.error?.statusCode) || 200, statusText: ctx.error?.statusMessage || "" });
     });
     nitro.hooks.hook("close", async () => {
-      const links = Object.entries(linkMap);
-      if (!links.length)
+      const payloads = Object.entries(linkMap);
+      if (!payloads.length)
         return;
-      nitro.logger.info(`Scanning routes for broken links... ${chalk.gray(`trailingSlashes: ${config.trailingSlash ? "`true`" : "`false`"}`)}`);
+      const links = payloads.map(([, payloads2]) => payloads2.links).flat();
+      const pageSearcher = new Fuse(links, {
+        threshold: 0.5
+      });
+      nitro.logger.info("Running link inspections...");
       let routeCount = 0;
-      let badLinkCount = 0;
-      links.forEach(([route, routes]) => {
-        const brokenLinks = routes.map((r) => {
-          return {
-            ...r,
-            statusCode: invalidRoutes[r.pathname] || 200
-          };
-        }).filter((r) => r.statusCode !== 200 || r.badTrailingSlash || r.badAbsolute).filter((r) => urlFilter(r.pathname));
-        if (brokenLinks.length) {
-          nitro.logger.log(chalk.gray(
-            `  ${Number(++routeCount) === links.length - 1 ? "\u2514\u2500" : "\u251C\u2500"} ${chalk.white(route)}`
-          ));
-          brokenLinks.forEach((link) => {
-            badLinkCount++;
-            nitro.logger.log("");
-            if (link.statusCode !== 200) {
-              nitro.logger.log(chalk.red(
-                `   ${link.statusCode} ${link.statusCode === 404 ? "Not Found" : "Redirect"}`
-              ));
-            } else if (link.badAbsolute) {
-              nitro.logger.log(chalk.yellow(
-                "   Absolute link, should be relative"
-              ));
-            } else if (link.badTrailingSlash) {
-              nitro.logger.log(chalk.yellow(
-                "   Incorrect trailing slash"
-              ));
-            }
-            nitro.logger.log(`   ${chalk.gray(link.element)}`);
+      let errorCount = 0;
+      await Promise.all(payloads.map(async ([route, payload]) => {
+        const reports = await Promise.all(payload.links.map(async (link) => {
+          const response = await getLinkResponse(link);
+          return inspect({
+            ids: linkMap[route].ids,
+            fromPath: route,
+            pageSearch: pageSearcher,
+            siteConfig,
+            link,
+            response,
+            skipInspections: config.skipInspections
           });
+        }));
+        const valid = !reports.filter((r) => !r.passes).length;
+        if (valid)
+          return;
+        const errors = reports.filter((r) => r.error?.length).length;
+        errorCount += errors;
+        const warnings = reports.filter((r) => r.warning?.length).length;
+        const statusString = [
+          errors > 0 ? chalk.red(`${errors} error${errors > 1 ? "s" : ""}`) : false,
+          warnings > 0 ? chalk.yellow(`${warnings} warning${warnings > 1 ? "s" : ""}`) : false
+        ].filter(Boolean).join(chalk.gray(", "));
+        nitro.logger.log(chalk.gray(
+          `  ${Number(++routeCount) === payload.links.length - 1 ? "\u2514\u2500" : "\u251C\u2500"} ${chalk.white(route)} ${chalk.gray("[")}${statusString}${chalk.gray("]")}`
+        ));
+        reports.forEach((report) => {
+          if (!report.passes) {
+            nitro.logger.log(chalk.gray(`    ${report.link}`));
+            report.error?.forEach((error) => {
+              nitro.logger.log(chalk.red(`        \u2716 ${error.message}`) + chalk.gray(` (${error.name})`));
+            });
+            report.warning?.forEach((warning) => {
+              nitro.logger.log(chalk.yellow(`        \u26A0 ${warning.message}`) + chalk.gray(` (${warning.name})`));
+            });
+          }
+        });
+        if (config.report?.html) {
+          if (reports.length) {
+            const reportHtml = reports.map((r) => {
+              const errors2 = r.error?.map((error) => {
+                return `<li class="error">${error.message} (${error.name})</li>`;
+              }).join("");
+              const warnings2 = r.warning?.map((warning) => {
+                return `<li class="warning">${warning.message} (${warning.name})</li>`;
+              }).join("");
+              return `<li class="link"><a href="${r.link}">${r.link}</a><ul>${errors2}${warnings2}</ul></li>`;
+            }).join("");
+            const html = `
+                <html>
+                    <head>
+                    <title>Link Checker Report</title>
+                    <style>
+                        body {
+                        font-family: sans-serif;
+                        }
+                        .link {
+                        margin-bottom: 1rem;
+                        }
+                        .error {
+                        color: red;
+                        }
+                        .warning {
+                        color: yellow;
+                        }
+                    </style>
+                    </head>
+                    <body>
+                    <h1>Link Checker Report</h1>
+                    <ul>
+                        ${reportHtml}
+                    </ul>
+                    </body>
+                </html>
+                `;
+            await fs.writeFile(resolve(nitro.options.output.dir, "link-checker-report.html"), html);
+            nitro.logger.info(`Nuxt Link Checker Report written to ${resolve(nitro.options.output.dir, "link-checker-report.html")}`);
+          }
         }
-      });
-      if (badLinkCount > 0) {
-        nitro.logger[config.failOn404 ? "error" : "warn"](`Found ${badLinkCount} broken links.`);
-        if (config.failOn404) {
-          nitro.logger.log(chalk.gray('You can disable this by setting "linkChecker: { failOn404: false }" in your nuxt.config.ts.'));
-          process.exit(1);
+        if (config.report?.markdown) {
+          if (reports.length) {
+            const reportMarkdown = reports.map((r) => {
+              const errors2 = r.error?.map((error) => {
+                return `| ${r.link} | ${error.message} (${error.name}) |`;
+              }).join("");
+              const warnings2 = r.warning?.map((warning) => {
+                return `| ${r.link} | ${warning.message} (${warning.name}) |`;
+              }).join("");
+              return `${errors2}${warnings2}`;
+            }).join("");
+            const markdown = [
+              "# Link Checker Report",
+              "",
+              "| Link | Message |",
+              "| --- | --- |",
+              reportMarkdown
+            ].join("\n");
+            await fs.writeFile(resolve(nitro.options.output.dir, "link-checker-report.md"), markdown);
+            nitro.logger.info(`Nuxt Link Checker Report written to ${resolve(nitro.options.output.dir, "link-checker-report.md")}`);
+          }
         }
-      } else {
-        nitro.logger.success("Looks good! No broken links found.");
+      }));
+      if (errorCount > 0 && config.failOnError) {
+        nitro.logger.error(`Nuxt Link Checker found ${errorCount} errors, failing build.`);
+        nitro.logger.log(chalk.gray('You can disable this by setting "linkChecker: { failOn404: false }" in your nuxt.config.ts.'));
+        process.exit(1);
       }
     });
   });
@@ -298,10 +567,14 @@ const module = defineNuxtModule({
     configKey: "linkChecker"
   },
   defaults: {
+    runOnBuild: true,
     debug: false,
+    showLiveInspections: true,
     enabled: true,
-    failOn404: true,
-    exclude: []
+    fetchTimeout: 5e3,
+    failOnError: false,
+    excludeLinks: [],
+    skipInspections: []
   },
   async setup(config, nuxt) {
     const logger = useLogger("nuxt-link-checker");
@@ -337,13 +610,18 @@ const module = defineNuxtModule({
           handler: resolve("./runtime/server/api/links")
         });
       }
-      nuxt.options.runtimeConfig["nuxt-link-checker"] = {
+      nuxt.options.runtimeConfig.public["nuxt-link-checker"] = {
         hasSitemapModule: hasNuxtModule("nuxt-simple-sitemap"),
-        hasLinksEndpoint
+        hasLinksEndpoint,
+        excludeLinks: config.excludeLinks,
+        skipInspections: config.skipInspections,
+        fetchTimeout: config.fetchTimeout,
+        showLiveInspections: config.showLiveInspections
       };
       setupDevToolsUI(config, resolve);
     }
-    prerender(config);
+    if (config.runOnBuild)
+      prerender(config);
   }
 });
 

package/dist/runtime/inspect.d.ts

@@ -1,2 +1,19 @@
 import type { LinkInspectionResult, Rule, RuleTestContext } from './types';
-export declare function inspect(ctx: RuleTestContext, rules?: Rule[]): Partial<LinkInspectionResult>;
+export declare const DefaultInspections: {
+    readonly 'missing-hash': Rule;
+    readonly 'no-error-response': Rule;
+    readonly 'no-baseless': Rule;
+    readonly 'no-javascript': Rule;
+    readonly 'trailing-slash': Rule;
+    readonly 'absolute-site-urls': Rule;
+    readonly redirects: Rule;
+};
+export declare function inspect(ctx: RuleTestContext, rules?: {
+    readonly 'missing-hash': Rule;
+    readonly 'no-error-response': Rule;
+    readonly 'no-baseless': Rule;
+    readonly 'no-javascript': Rule;
+    readonly 'trailing-slash': Rule;
+    readonly 'absolute-site-urls': Rule;
+    readonly redirects: Rule;
+}): Partial<LinkInspectionResult>;

package/dist/runtime/inspect.mjs

@@ -1,6 +1,4 @@
-import { getHeader } from "h3";
 import { parseURL } from "ufo";
-import { fixSlashes } from "site-config-stack";
 import RuleTrailingSlash from "./inspections/trailing-slash.mjs";
 import RuleMissingHash from "./inspections/missing-hash.mjs";
 import RuleNoBaseLess from "./inspections/no-baseless.mjs";
@@ -8,22 +6,20 @@ import RuleNoJavascript from "./inspections/no-javascript.mjs";
 import RuleAbsoluteSiteUrls from "./inspections/absolute-site-urls.mjs";
 import RuleRedirects from "./inspections/redirects.mjs";
 import RuleNoErrorResponse from "./inspections/no-error-response-status.mjs";
-const inspection = [
-  RuleMissingHash(),
-  RuleNoErrorResponse(),
-  RuleNoBaseLess(),
-  RuleNoJavascript(),
-  RuleTrailingSlash(),
-  RuleAbsoluteSiteUrls(),
-  RuleRedirects()
-];
-export function inspect(ctx, rules) {
-  if (!rules)
-    rules = inspection;
+export const DefaultInspections = {
+  "missing-hash": RuleMissingHash(),
+  "no-error-response": RuleNoErrorResponse(),
+  "no-baseless": RuleNoBaseLess(),
+  "no-javascript": RuleNoJavascript(),
+  "trailing-slash": RuleTrailingSlash(),
+  "absolute-site-urls": RuleAbsoluteSiteUrls(),
+  "redirects": RuleRedirects()
+};
+export function inspect(ctx, rules = DefaultInspections) {
   const res = { error: [], warning: [], fix: ctx.link, link: ctx.link };
   let link = ctx.link;
   const url = parseURL(link);
-  if (!url.pathname && !url.protocol && !url.host) {
+  if (!url.pathname && !url.protocol && !url.host && !link.startsWith("javascript:")) {
     res.error.push({
       name: "invalid-url",
       scope: "error",
@@ -31,13 +27,12 @@ export function inspect(ctx, rules) {
     });
     return res;
   }
-  const fromPath = fixSlashes(false, parseURL(getHeader(ctx.e, "referer") || "/").pathname);
-  for (const rule of rules) {
+  const validInspections = Object.entries(rules).filter(([name]) => !ctx.skipInspections || !ctx.skipInspections.includes(name)).map(([, rule]) => rule);
+  for (const rule of validInspections) {
     rule.test({
       ...ctx,
       link,
       url,
-      fromPath,
       report(obj) {
         res[obj.scope].push(obj);
         if (obj.fix)

package/dist/runtime/inspections/no-baseless.mjs

@@ -1,12 +1,10 @@
 import { joinURL } from "ufo";
-import { getHeader } from "h3";
 import { defineRule, isInvalidLinkProtocol } from "./util.mjs";
 export default function RuleNoBaseLess() {
   return defineRule({
-    test({ link, e, report }) {
+    test({ link, fromPath, report }) {
       if (link.startsWith("/") || link.startsWith("http") || isInvalidLinkProtocol(link) || link.startsWith("#"))
         return;
-      const fromPath = getHeader(e, "referer") || "";
       report({
         name: "no-baseless",
         scope: "warning",

package/dist/runtime/inspections/no-error-response-status.mjs

@@ -9,7 +9,7 @@ export default function RuleNoErrorResponse() {
         scope: "error",
         message: `Should not respond with ${response.status} ${response.statusText}.`
       };
-      if (link.startsWith("/")) {
+      if (link.startsWith("/") && pageSearch) {
         const fix = pageSearch.search(link)?.[0]?.item;
         if (fix && fix !== link) {
           payload.fix = fix;

package/dist/runtime/inspections/redirects.mjs

@@ -10,10 +10,10 @@ export default function RuleRedirects() {
         message: "Should not redirect.",
         tip: "Redirects use up your crawl budget and increase loading times, it's recommended to avoid them when possible."
       };
-      const fix = response.headers.get("location");
+      const fix = typeof response.headers?.get === "function" ? response.headers.get("location") : response.headers?.location || false;
       if (fix) {
         payload.fix = fix;
-        payload.fixDescription = `Set to redirected URL ${fix}.`;
+        payload.fixDescription = `Set to redirect URL ${fix}.`;
       }
       report(payload);
     }

package/dist/runtime/plugin/search.nitro.mjs

@@ -2,7 +2,7 @@ import Fuse from "fuse.js";
 import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
 import { useRuntimeConfig } from "#imports";
 export default defineNitroPlugin(async (nitro) => {
-  const runtimeConfig = useRuntimeConfig()["nuxt-link-checker"];
+  const runtimeConfig = useRuntimeConfig().public["nuxt-link-checker"];
   const pages = runtimeConfig.hasLinksEndpoint ? await $fetch("/api/__link_checker__/links") : [];
   nitro._linkCheckerPageSearch = new Fuse(pages, {
     threshold: 0.5

package/dist/runtime/plugin/view/client.mjs

@@ -1,7 +1,8 @@
 import { computed, createApp, h, ref, shallowReactive, unref } from "vue";
+import { createFilter } from "../../../urlFilter";
 import Main from "./Main.vue";
 import { linkDb } from "./state.mjs";
-import { useRoute } from "#imports";
+import { useRoute, useRuntimeConfig } from "#imports";
 function resolveDevtoolsIframe() {
   return document.querySelector("#nuxt-devtools-iframe")?.contentWindow?.__NUXT_DEVTOOLS__;
 }
@@ -25,17 +26,23 @@ export async function setupLinkCheckerClient({ nuxt }) {
   let devtoolsClient;
   let isOpeningDevtools = false;
   const route = useRoute();
-  let startQueueId;
-  let domUpdateTimer;
+  let startQueueIdleId;
+  let startQueueTimeoutId;
+  const runtimeConfig = useRuntimeConfig().public["nuxt-link-checker"];
+  const filter = createFilter({
+    exclude: runtimeConfig.excludeLinks
+  });
   const client = shallowReactive({
     isWorkingQueue: false,
     scanLinks() {
       elMap = {};
       visibleLinks.clear();
       const ids = [...new Set([...document.querySelectorAll("#__nuxt [id]")].map((el) => el.id))];
-      [...document.querySelectorAll("#__nuxt a")].map((el) => ({ el, link: el.getAttribute("href") })).forEach(({ el, link }) => {
+      [...document.querySelectorAll("#__nuxt a[href]")].map((el) => ({ el, link: el.getAttribute("href") })).forEach(({ el, link }) => {
         if (!link)
           return;
+        if (!filter(link))
+          return;
         visibleLinks.add(link);
         elMap[link] = elMap[link] || [];
         if (elMap[link].includes(el))
@@ -88,7 +95,7 @@ export async function setupLinkCheckerClient({ nuxt }) {
       workQueue();
     },
     maybeAttachEls(payload) {
-      if (!payload || payload.passes)
+      if (!payload || payload.passes || !runtimeConfig.showLiveInspections)
         return;
       const els = elMap?.[payload.link] || [];
       for (const el of els)
@@ -144,11 +151,16 @@ export async function setupLinkCheckerClient({ nuxt }) {
       client.restart();
     },
     restart() {
-      startQueueId && cancelIdleCallback(startQueueId);
-      startQueueId = requestIdleCallback(() => {
+      startQueueIdleId && cancelIdleCallback(startQueueIdleId);
+      startQueueIdleId = requestIdleCallback(() => {
         client.stopQueueWorker();
-        client.scanLinks();
-        client.startQueueWorker();
+        if (!startQueueTimeoutId) {
+          startQueueTimeoutId = setTimeout(() => {
+            client.scanLinks();
+            client.startQueueWorker();
+            startQueueTimeoutId = false;
+          }, 250);
+        }
       });
     },
     start() {
@@ -157,18 +169,19 @@ export async function setupLinkCheckerClient({ nuxt }) {
           client.reset(true);
         });
         import.meta.hot.on("vite:afterUpdate", (ctx) => {
-          console.log("vite after update", ctx.type, ctx.updates);
           if (ctx.updates.some((c) => c.type === "js-update"))
             client.reset(true);
         });
       }
       const observer = new MutationObserver(() => {
-        domUpdateTimer && clearTimeout(domUpdateTimer);
-        domUpdateTimer = setTimeout(() => {
-          client.reset(false);
-        }, 500);
+        client.reset(false);
+      });
+      observer.observe(document.querySelector("#__nuxt"), {
+        childList: true,
+        subtree: true,
+        // we only care if links are added, removed or updated
+        attributeFilter: ["href"]
       });
-      observer.observe(document.querySelector("#__nuxt"), { childList: true, subtree: true });
       if (nuxt.vueApp._instance)
         nuxt.vueApp._instance.appContext.provides.linkChecker = client;
       const holder = document.createElement("div");

package/dist/runtime/server/api/inspect.mjs

@@ -1,36 +1,36 @@
-import { defineEventHandler, getQuery, readBody } from "h3";
+import { defineEventHandler, getHeader, getQuery, readBody } from "h3";
+import { fixSlashes } from "site-config-stack";
+import { parseURL } from "ufo";
 import { inspect } from "../../inspect.mjs";
 import { generateFileLinkDiff, generateFileLinkPreviews } from "../util.mjs";
 import { isInvalidLinkProtocol } from "../../inspections/util.mjs";
-import { useNitroApp, useSiteConfig } from "#imports";
+import { crawlFetch } from "../../sharedUtils.mjs";
+import { useNitroApp, useRuntimeConfig, useSiteConfig } from "#imports";
 export default defineEventHandler(async (e) => {
   const link = decodeURIComponent(getQuery(e).link);
   const body = await readBody(e);
   const { ids, paths } = body;
   const partialCtx = {
     ids,
-    e,
+    fromPath: fixSlashes(false, parseURL(getHeader(e, "referer") || "/").pathname),
     siteConfig: useSiteConfig(e)
   };
+  const runtimeConfig = useRuntimeConfig().public["nuxt-link-checker"];
   let response;
   if (isInvalidLinkProtocol(link) || link.startsWith("#")) {
     response = { status: 200, statusText: "OK", headers: {} };
   } else {
-    const timeoutController = new AbortController();
-    const abortRequestTimeout = setTimeout(() => timeoutController.abort(), 5e3);
-    response = await $fetch.raw(link, {
-      method: "HEAD",
-      signal: timeoutController.signal,
-      headers: {
-        "user-agent": "Nuxt Link Checker"
-      }
-    }).catch(() => ({ status: 404, statusText: "Not Found", headers: {} })).finally(() => clearTimeout(abortRequestTimeout));
+    response = await crawlFetch(link, {
+      fetch: $fetch.raw,
+      timeout: runtimeConfig.timeout
+    });
   }
   const result = inspect({
     ...partialCtx,
     link,
     pageSearch: useNitroApp()._linkCheckerPageSearch,
-    response
+    response,
+    skipInspections: runtimeConfig.skipInspections
   });
   const filePaths = paths.map((p) => {
     const [filepath] = p.split(":");

package/dist/runtime/server/api/links.mjs

@@ -1,7 +1,7 @@
 import { defineEventHandler } from "h3";
 import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async () => {
-  const runtimeConfig = useRuntimeConfig()["nuxt-link-checker"];
+  const runtimeConfig = useRuntimeConfig().public["nuxt-link-checker"];
   const linkDb = [];
   if (runtimeConfig.hasSitemapModule) {
     const sitemapDebug = await $fetch("/api/__sitemap__/debug");

package/dist/runtime/sharedUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function crawlFetch(link: string, options?: {
+    fetch?: typeof globalThis.fetch;
+    timeout?: number;
+}): Promise<Response | {
+    status: number;
+    statusText: string;
+    headers: {};
+}>;

package/dist/runtime/sharedUtils.mjs

@@ -0,0 +1,13 @@
+export async function crawlFetch(link, options = {}) {
+  const fetch = options.fetch || globalThis.fetch;
+  const timeout = options.timeout || 5e3;
+  const timeoutController = new AbortController();
+  const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
+  return await fetch(link, {
+    method: "HEAD",
+    signal: timeoutController.signal,
+    headers: {
+      "user-agent": "Nuxt Link Checker"
+    }
+  }).catch(() => ({ status: 404, statusText: "Not Found", headers: {} })).finally(() => clearTimeout(abortRequestTimeout));
+}

package/dist/runtime/types.d.ts

@@ -1,5 +1,4 @@
 import type { FetchResponse } from 'ofetch';
-import type { H3Event } from 'h3';
 import type { SiteConfig } from 'nuxt-site-config-kit';
 import type Fuse from 'fuse.js';
 import type { ComputedRef, Ref } from 'vue';
@@ -13,10 +12,10 @@ export interface RuleTestContext {
     ids: string[];
     fromPath: string;
     response: FetchResponse<any>;
-    e: H3Event;
     siteConfig: SiteConfig;
-    pageSearch: Fuse<string>;
+    pageSearch?: Fuse<string>;
     report: (report: RuleReport) => void;
+    skipInspections?: string[];
 }
 export interface RuleReport {
     name: string;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nuxt-link-checker",
   "type": "module",
-  "version": "2.0.0-beta.5",
-  "packageManager": "pnpm@8.6.10",
+  "version": "2.0.0-beta.7",
+  "packageManager": "pnpm@8.6.11",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
   "homepage": "https://github.com/harlan-zw/nuxt-link-checker#readme",
@@ -20,6 +20,11 @@
       "import": "./dist/module.mjs"
     }
   },
+  "build": {
+    "externals": [
+      "ofetch"
+    ]
+  },
   "main": "./dist/module.cjs",
   "types": "./dist/types.d.ts",
   "files": [
@@ -41,6 +46,7 @@
     "radix3": "^1.0.1",
     "shiki-es": "^0.14.0",
     "sirv": "^2.0.3",
+    "site-config-stack": "^1.0.9",
     "ufo": "^1.2.0"
   },
   "devDependencies": {