nuxt-link-checker 3.1.2 → 3.2.0

package/dist/module.mjs

@@ -2,32 +2,174 @@ import { useNuxt, extendPages, defineNuxtModule, createResolver, useLogger, addP
 import { useSiteConfig, installNuxtSiteConfig } from 'nuxt-site-config-kit';
 import { readPackageJSON } from 'pkg-types';
 import { existsSync } from 'node:fs';
-import chalk from 'chalk';
-import Fuse from 'fuse.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
+import { diffArrays } from 'diff';
 import { resolve, relative } from 'pathe';
+import { generateLinkDiff } from '../dist/runtime/shared/diff.js';
+import { joinURL, withoutLeadingSlash } from 'ufo';
+import chalk from 'chalk';
 import { load } from 'cheerio';
-import { withoutLeadingSlash, joinURL } from 'ufo';
+import Fuse from 'fuse.js';
 import { createStorage } from 'unstorage';
 import fsDriver from 'unstorage/drivers/fs';
-import { inspect } from '../dist/runtime/pure/inspect.js';
-import { createFilter } from '../dist/runtime/pure/sharedUtils.js';
-import { setLinkResponse, getLinkResponse, crawlFetch } from '../dist/runtime/pure/crawl.js';
-import { readFile, writeFile } from 'node:fs/promises';
-import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
-import { diffArrays } from 'diff';
-import { generateLinkDiff } from '../dist/runtime/pure/diff.js';
+import { setLinkResponse, getLinkResponse, crawlFetch } from '../dist/runtime/shared/crawl.js';
+import { inspect } from '../dist/runtime/shared/inspect.js';
+import { createFilter } from '../dist/runtime/shared/sharedUtils.js';
+
+function convertNuxtPagesToPaths(pages) {
+  return pages.map((page) => {
+    return page.children?.length ? page.children.map((child) => {
+      return {
+        path: joinURL(page.path, child.path),
+        page: child
+      };
+    }) : { page, path: page.path };
+  }).flat().filter((p) => !p.path.includes(":")).map((p) => ({
+    title: p.page?.meta?.title || "",
+    link: p.path
+  }));
+}
+function useViteWebSocket(nuxt = useNuxt()) {
+  return new Promise((_resolve) => {
+    nuxt.hooks.hook("vite:serverCreated", (viteServer) => {
+      _resolve(viteServer.ws);
+    });
+  });
+}
+
+const DEVTOOLS_UI_ROUTE = "/__nuxt-link-checker";
+const DEVTOOLS_UI_LOCAL_PORT = 3030;
+const RPC_NAMESPACE = "nuxt-link-checker-rpc";
+function setupDevToolsUI(options, moduleResolve, nuxt = useNuxt()) {
+  const clientPath = moduleResolve("./client");
+  const isProductionBuild = existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(
+        DEVTOOLS_UI_ROUTE,
+        sirv(clientPath, { dev: true, single: true })
+      );
+    });
+  } else {
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
+      };
+    });
+  }
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    tabs.push({
+      // unique identifier
+      name: "nuxt-link-checker",
+      // title to display in the tab
+      title: "Link Checker",
+      // any icon from Iconify, or a URL to an image
+      icon: "carbon:cloud-satellite-link",
+      // iframe view
+      view: {
+        type: "iframe",
+        src: DEVTOOLS_UI_ROUTE
+      }
+    });
+  });
+  let isConnected = false;
+  const viteServerWs = useViteWebSocket();
+  const rpc = new Promise((promiseResolve) => {
+    onDevToolsInitialized(async () => {
+      const rpc2 = extendServerRpc(RPC_NAMESPACE, {
+        getOptions() {
+          return options;
+        },
+        async reset() {
+          const ws = await viteServerWs;
+          ws.send("nuxt-link-checker:reset");
+        },
+        async scrollToLink(link) {
+          const ws = await viteServerWs;
+          ws.send("nuxt-link-checker:scroll-to-link", link);
+        },
+        async applyLinkFixes(diff, original, replacement) {
+          for (const { filepath } of diff) {
+            const rootDirFolderName = nuxt.options.rootDir.split("/").pop();
+            const filepathWithoutRoot = filepath.replace(new RegExp(`^${nuxt.options.rootDir}/`), "").replace(new RegExp(`^${rootDirFolderName}/`), "");
+            const fp = resolve(nuxt.options.rootDir, filepathWithoutRoot);
+            const contents = await readFile(fp, "utf8");
+            const diff2 = generateLinkDiff(contents, original, replacement);
+            await writeFile(fp, diff2.code, "utf8");
+          }
+          const ws = await viteServerWs;
+          ws.send("nuxt-link-checker:reset");
+        },
+        async toggleLiveInspections(enabled) {
+          const ws = await viteServerWs;
+          ws.send("nuxt-link-checker:live-inspections", { enabled });
+        },
+        async connected() {
+          const ws = await viteServerWs;
+          ws.send("nuxt-link-checker:connected");
+          isConnected = true;
+        }
+      });
+      promiseResolve(rpc2);
+    });
+  });
+  viteServerWs.then((ws) => {
+    ws.on("nuxt-link-checker:queueWorking", async (payload) => {
+      if (isConnected) {
+        const _rpc = await rpc;
+        _rpc.broadcast.queueWorking(payload).catch(() => {
+        });
+      }
+    });
+    ws.on("nuxt-link-checker:updated", async () => {
+      if (isConnected) {
+        const _rpc = await rpc;
+        _rpc.broadcast.updated().catch(() => {
+        });
+      }
+    });
+    ws.on("nuxt-link-checker:filter", async (payload) => {
+      if (isConnected) {
+        const _rpc = await rpc;
+        _rpc.broadcast.filter(payload).catch(() => {
+        });
+      }
+    });
+    let lastRoutes = [];
+    extendPages(async (pages) => {
+      const routes = convertNuxtPagesToPaths(pages);
+      if (lastRoutes.length) {
+        const routeDiff = diffArrays(lastRoutes, routes);
+        if (routeDiff.some((diff) => diff.added || diff.removed))
+          ws.send("nuxt-link-checker:reset");
+      }
+      lastRoutes = routes;
+    });
+  });
+}
 
 const linkMap = {};
-function extractPayload(html) {
+function extractPayload(html, rootNodeId = "#__nuxt") {
+  if (String(rootNodeId).length) {
+    rootNodeId = rootNodeId[0] === "#" ? rootNodeId : `#${rootNodeId}`;
+  }
   const $ = load(html);
-  const ids = $("#__nuxt [id]").map((i, el) => $(el).attr("id")).get();
+  const ids = $(`${rootNodeId} [id]`.trim()).map((i, el) => $(el).attr("id")).get();
   const title = $("title").text();
-  const links = $("#__nuxt a[href]").map((i, el) => {
+  const links = $(`${rootNodeId} a`.trim()).map((i, el) => {
     return {
+      role: $(el).attr("role") || "",
       link: $(el).attr("href") || "",
       textContent: ($(el).attr("aria-label") || $(el).attr("title") || $(el).text()).trim() || ""
     };
-  }).get().filter((l) => !!l.link);
+  }).get();
   return { title, ids, links };
 }
 function isNuxtGenerate(nuxt = useNuxt()) {
@@ -42,7 +184,7 @@ function prerender(config, nuxt = useNuxt()) {
     nitro.hooks.hook("prerender:generate", async (ctx) => {
       const route = decodeURI(ctx.route);
       if (ctx.contents && !ctx.error && ctx.fileName?.endsWith(".html") && !route.endsWith(".html") && urlFilter(route))
-        linkMap[route] = extractPayload(ctx.contents);
+        linkMap[route] = extractPayload(ctx.contents, nuxt.options.app.rootAttrs?.id || "");
       setLinkResponse(route, Promise.resolve({ status: Number(ctx.error?.statusCode) || 200, statusText: ctx.error?.statusMessage || "", headers: {} }));
     });
     nitro.hooks.hook("prerender:done", async () => {
@@ -230,144 +372,6 @@ function prerender(config, nuxt = useNuxt()) {
   });
 }
 
-function convertNuxtPagesToPaths(pages) {
-  return pages.map((page) => {
-    return page.children?.length ? page.children.map((child) => {
-      return {
-        path: joinURL(page.path, child.path),
-        page: child
-      };
-    }) : { page, path: page.path };
-  }).flat().filter((p) => !p.path.includes(":")).map((p) => ({
-    title: p.page?.meta?.title || "",
-    link: p.path
-  }));
-}
-function useViteWebSocket(nuxt = useNuxt()) {
-  return new Promise((_resolve) => {
-    nuxt.hooks.hook("vite:serverCreated", (viteServer) => {
-      _resolve(viteServer.ws);
-    });
-  });
-}
-
-const DEVTOOLS_UI_ROUTE = "/__nuxt-link-checker";
-const DEVTOOLS_UI_LOCAL_PORT = 3030;
-const RPC_NAMESPACE = "nuxt-link-checker-rpc";
-function setupDevToolsUI(options, moduleResolve, nuxt = useNuxt()) {
-  const clientPath = moduleResolve("./client");
-  const isProductionBuild = existsSync(clientPath);
-  if (isProductionBuild) {
-    nuxt.hook("vite:serverCreated", async (server) => {
-      const sirv = await import('sirv').then((r) => r.default || r);
-      server.middlewares.use(
-        DEVTOOLS_UI_ROUTE,
-        sirv(clientPath, { dev: true, single: true })
-      );
-    });
-  } else {
-    nuxt.hook("vite:extendConfig", (config) => {
-      config.server = config.server || {};
-      config.server.proxy = config.server.proxy || {};
-      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
-        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
-        changeOrigin: true,
-        followRedirects: true,
-        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
-      };
-    });
-  }
-  nuxt.hook("devtools:customTabs", (tabs) => {
-    tabs.push({
-      // unique identifier
-      name: "nuxt-link-checker",
-      // title to display in the tab
-      title: "Link Checker",
-      // any icon from Iconify, or a URL to an image
-      icon: "carbon:cloud-satellite-link",
-      // iframe view
-      view: {
-        type: "iframe",
-        src: DEVTOOLS_UI_ROUTE
-      }
-    });
-  });
-  let isConnected = false;
-  const viteServerWs = useViteWebSocket();
-  const rpc = new Promise((promiseResolve) => {
-    onDevToolsInitialized(async () => {
-      const rpc2 = extendServerRpc(RPC_NAMESPACE, {
-        getOptions() {
-          return options;
-        },
-        async reset() {
-          const ws = await viteServerWs;
-          ws.send("nuxt-link-checker:reset");
-        },
-        async scrollToLink(link) {
-          const ws = await viteServerWs;
-          ws.send("nuxt-link-checker:scroll-to-link", link);
-        },
-        async applyLinkFixes(diff, original, replacement) {
-          for (const { filepath } of diff) {
-            const rootDirFolderName = nuxt.options.rootDir.split("/").pop();
-            const filepathWithoutRoot = filepath.replace(new RegExp(`^${nuxt.options.rootDir}/`), "").replace(new RegExp(`^${rootDirFolderName}/`), "");
-            const fp = resolve(nuxt.options.rootDir, filepathWithoutRoot);
-            const contents = await readFile(fp, "utf8");
-            const diff2 = generateLinkDiff(contents, original, replacement);
-            await writeFile(fp, diff2.code, "utf8");
-          }
-          const ws = await viteServerWs;
-          ws.send("nuxt-link-checker:reset");
-        },
-        async toggleLiveInspections(enabled) {
-          const ws = await viteServerWs;
-          ws.send("nuxt-link-checker:live-inspections", { enabled });
-        },
-        async connected() {
-          const ws = await viteServerWs;
-          ws.send("nuxt-link-checker:connected");
-          isConnected = true;
-        }
-      });
-      promiseResolve(rpc2);
-    });
-  });
-  viteServerWs.then((ws) => {
-    ws.on("nuxt-link-checker:queueWorking", async (payload) => {
-      if (isConnected) {
-        const _rpc = await rpc;
-        _rpc.broadcast.queueWorking(payload).catch(() => {
-        });
-      }
-    });
-    ws.on("nuxt-link-checker:updated", async () => {
-      if (isConnected) {
-        const _rpc = await rpc;
-        _rpc.broadcast.updated().catch(() => {
-        });
-      }
-    });
-    ws.on("nuxt-link-checker:filter", async (payload) => {
-      if (isConnected) {
-        const _rpc = await rpc;
-        _rpc.broadcast.filter(payload).catch(() => {
-        });
-      }
-    });
-    let lastRoutes = [];
-    extendPages(async (pages) => {
-      const routes = convertNuxtPagesToPaths(pages);
-      if (lastRoutes.length) {
-        const routeDiff = diffArrays(lastRoutes, routes);
-        if (routeDiff.some((diff) => diff.added || diff.removed))
-          ws.send("nuxt-link-checker:reset");
-      }
-      lastRoutes = routes;
-    });
-  });
-}
-
 const module = defineNuxtModule({
   meta: {
     name: "nuxt-link-checker",
@@ -408,20 +412,20 @@ const module = defineNuxtModule({
     const isDevToolsEnabled = typeof nuxt.options.devtools === "boolean" ? nuxt.options.devtools : nuxt.options.devtools.enabled;
     if (nuxt.options.dev && isDevToolsEnabled) {
       addPlugin({
-        src: resolve("./runtime/nuxt/plugin/ui.client"),
+        src: resolve("./runtime/app/plugins/ui.client"),
         mode: "client"
       });
       addServerHandler({
         route: "/__link-checker__/inspect",
-        handler: resolve("./runtime/nitro/routes/__link-checker__/inspect")
+        handler: resolve("./runtime/server/routes/__link-checker__/inspect")
       });
       addServerHandler({
         route: "/__link-checker__/links",
-        handler: resolve("./runtime/nitro/routes/__link-checker__/links")
+        handler: resolve("./runtime/server/routes/__link-checker__/links")
       });
       addServerHandler({
         route: "/__link-checker__/debug.json",
-        handler: resolve("./runtime/nitro/routes/__link-checker__/debug")
+        handler: resolve("./runtime/server/routes/__link-checker__/debug")
       });
       const pagePromise = new Promise((_resolve) => {
         extendPages((pages) => {
@@ -437,9 +441,9 @@ const module = defineNuxtModule({
       const hasSitemapModule = (hasNuxtModule("@nuxtjs/sitemap") || hasNuxtModule("nuxt-simple-sitemap") && await hasNuxtModuleCompatibility("nuxt-simple-sitemap", ">=4")) && nuxt.options.sitemap?.enabled !== false;
       nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
       if (!hasNuxtModule("@nuxt/content")) {
-        nuxt.options.nitro.alias["#content/server"] = resolve("./runtime/nitro/composables/content-mock");
+        nuxt.options.nitro.alias["#content/server"] = resolve("./runtime/server/composables/content-mock");
       }
-      nuxt.options.nitro.alias["#link-checker/pure"] = resolve("./runtime/pure");
+      nuxt.options.nitro.alias["#link-checker/shared"] = resolve("./runtime/shared");
       nuxt.options.runtimeConfig.public["nuxt-link-checker"] = {
         version,
         hasSitemapModule,

package/dist/runtime/{nuxt/plugin → app/plugins}/view/Main.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
-import { type Ref, computed, ref } from 'vue'
 import type { NuxtLinkCheckerClient } from '../../../types'
+import { computed, type Ref, ref } from 'vue'
 import Squiggle from './Squiggle.vue'
 import { useEventListener } from './utils'
 

package/dist/runtime/{nuxt/plugin → app/plugins}/view/client.js

@@ -1,9 +1,9 @@
-import { computed, createApp, h, ref, shallowReactive, unref } from "vue";
+import { useRuntimeConfig } from "#imports";
 import { useLocalStorage } from "@vueuse/core";
-import { createFilter } from "../../../pure/sharedUtils.js";
+import { computed, createApp, h, ref, shallowReactive, unref } from "vue";
+import { createFilter } from "../../../shared/sharedUtils.js";
 import Main from "./Main.vue";
 import { linkDb } from "./state.js";
-import { useRuntimeConfig } from "#imports";
 function resolveDevtoolsIframe() {
   const iframe = document.querySelector("#nuxt-devtools-iframe");
   if (!iframe)
@@ -47,7 +47,7 @@ export async function setupLinkCheckerClient({ nuxt, route }) {
       elMap = {};
       visibleLinks.clear();
       lastIds = [...new Set([...document.querySelectorAll("#__nuxt [id]")].map((el) => el.id))];
-      [...document.querySelectorAll("#__nuxt a[href]")].map((el) => ({ el, link: el.getAttribute("href") })).forEach(({ el, link }) => {
+      [...document.querySelectorAll("#__nuxt a")].map((el) => ({ el, link: el.getAttribute("href") })).forEach(({ el, link }) => {
         if (!link)
           return;
         if (!filter(link))
@@ -65,6 +65,7 @@ export async function setupLinkCheckerClient({ nuxt, route }) {
         }
         queue.push({
           link,
+          role: el.getAttribute("role") || "",
           textContent: (el.textContent || el.getAttribute("aria-label") || el.getAttribute("title") || "").trim(),
           paths
         });

package/dist/runtime/{nitro → server}/routes/__link-checker__/inspect.js

@@ -1,10 +1,10 @@
+import { useNitroOrigin, useRuntimeConfig, useSiteConfig } from "#imports";
+import Fuse from "fuse.js";
 import { defineEventHandler, getHeader, readBody } from "h3";
+import { resolve } from "pathe";
 import { fixSlashes } from "site-config-stack/urls";
 import { parseURL } from "ufo";
-import { resolve } from "pathe";
-import Fuse from "fuse.js";
-import { generateFileLinkDiff, generateFileLinkPreviews, getLinkResponse, inspect, isNonFetchableLink, lruFsCache } from "#link-checker/pure";
-import { useNitroOrigin, useRuntimeConfig, useSiteConfig } from "#imports";
+import { generateFileLinkDiff, generateFileLinkPreviews, getLinkResponse, inspect, isNonFetchableLink, lruFsCache } from "#link-checker/shared";
 import { serverQueryContent } from "#content/server";
 function isInternalRoute(path) {
   const lastSegment = path.split("/").pop() || path;

package/dist/runtime/{pure → shared}/index.d.ts

@@ -1,5 +1,5 @@
-import { inspect } from './inspect.js';
-import { generateFileLinkDiff, generateFileLinkPreviews, lruFsCache } from './diff.js';
 import { getLinkResponse } from './crawl.js';
+import { generateFileLinkDiff, generateFileLinkPreviews, lruFsCache } from './diff.js';
+import { inspect } from './inspect.js';
 import { isNonFetchableLink } from './inspections/util.js';
-export { inspect, generateFileLinkDiff, generateFileLinkPreviews, lruFsCache, getLinkResponse, isNonFetchableLink, };
+export { generateFileLinkDiff, generateFileLinkPreviews, getLinkResponse, inspect, isNonFetchableLink, lruFsCache, };

package/dist/runtime/{pure → shared}/index.js

@@ -1,12 +1,12 @@
-import { inspect } from "./inspect.js";
-import { generateFileLinkDiff, generateFileLinkPreviews, lruFsCache } from "./diff.js";
 import { getLinkResponse } from "./crawl.js";
+import { generateFileLinkDiff, generateFileLinkPreviews, lruFsCache } from "./diff.js";
+import { inspect } from "./inspect.js";
 import { isNonFetchableLink } from "./inspections/util.js";
 export {
-  inspect,
   generateFileLinkDiff,
   generateFileLinkPreviews,
-  lruFsCache,
   getLinkResponse,
-  isNonFetchableLink
+  inspect,
+  isNonFetchableLink,
+  lruFsCache
 };

package/dist/runtime/{pure → shared}/inspect.js

@@ -1,19 +1,32 @@
 import { parseURL } from "ufo";
-import RuleTrailingSlash from "./inspections/trailing-slash.js";
+import RuleAbsoluteSiteUrls from "./inspections/absolute-site-urls.js";
+import RuleDescriptiveLinkText from "./inspections/link-text.js";
 import RuleMissingHash from "./inspections/missing-hash.js";
-import RuleNoBaseLess from "./inspections/no-baseless.js";
+import RuleNoDocumentRelative from "./inspections/no-baseless.js";
+import RuleNoDoubleSlashes from "./inspections/no-double-slashes.js";
+import RuleNoDuplicateQueryParams from "./inspections/no-duplicate-query-params.js";
+import RuleNoErrorResponse from "./inspections/no-error-response.js";
 import RuleNoJavascript from "./inspections/no-javascript.js";
-import RuleAbsoluteSiteUrls from "./inspections/absolute-site-urls.js";
+import RuleNoMissingHref from "./inspections/no-missing-href.js";
+import RuleNoNonAsciiChars from "./inspections/no-non-ascii-chars.js";
+import RuleNoUnderscores from "./inspections/no-underscores.js";
+import RuleNoUppercaseChars from "./inspections/no-uppercase-chars.js";
+import RuleNoWhitespace from "./inspections/no-whitespace.js";
+import RuleTrailingSlash from "./inspections/trailing-slash.js";
 import RuleRedirects from "./redirects.js";
-import RuleNoErrorResponse from "./inspections/no-error-response-status.js";
-import RuleDescriptiveLinkText from "./inspections/descriptive-link-text.js";
-import { isNonFetchableLink } from "./inspections/util.js";
 export const AllInspections = [
+  RuleNoMissingHref(),
+  RuleNoDuplicateQueryParams(),
+  RuleNoNonAsciiChars(),
   RuleMissingHash(),
+  RuleNoUnderscores(),
+  RuleNoWhitespace(),
+  RuleNoDoubleSlashes(),
   RuleNoErrorResponse(),
-  RuleNoBaseLess(),
+  RuleNoDocumentRelative(),
   RuleNoJavascript(),
   RuleTrailingSlash(),
+  RuleNoUppercaseChars(),
   RuleAbsoluteSiteUrls(),
   RuleRedirects(),
   RuleDescriptiveLinkText()
@@ -23,26 +36,24 @@ export function inspect(ctx, rules) {
   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 && !isNonFetchableLink(link)) {
-    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);
+  const validInspections = rules.filter(({ id }) => !(ctx.skipInspections || []).includes(id));
+  let processing = true;
   for (const rule of validInspections) {
     rule.test({
       ...ctx,
       link,
       url,
-      report(obj) {
+      report(obj, stop) {
+        if (stop) {
+          processing = false;
+        }
         res[obj.scope].push(obj);
         if (obj.fix)
           link = obj.fix;
       }
     });
+    if (!processing)
+      break;
   }
   res.passes = !res.error?.length && !res.warning?.length;
   res.fix = link;

package/dist/runtime/{pure/inspections/descriptive-link-text.js → shared/inspections/link-text.js}

@@ -9,7 +9,7 @@ export default function RuleDescriptiveLinkText() {
         report({
           name: "link-text",
           scope: "warning",
-          message: "Should have descriptive text.",
+          message: "Missing link textContent, title or aria-label.",
           tip: "Links with descriptive text are easier to understand for screen readers and search engines."
         });
       }
@@ -29,7 +29,7 @@ export default function RuleDescriptiveLinkText() {
         report({
           name: "link-text",
           scope: "warning",
-          message: "Should have descriptive text.",
+          message: `Link text "${textContent}" should be more descriptive.`,
           tip: `The ${textContent} descriptive text does not provide any context to the link.`
         });
       }

package/dist/runtime/shared/inspections/no-baseless.d.ts

@@ -0,0 +1 @@
+export default function RuleNoDocumentRelative(): import("../../types").Rule;

package/dist/runtime/{pure → shared}/inspections/no-baseless.js

@@ -1,15 +1,16 @@
 import { joinURL } from "ufo";
 import { defineRule, isNonFetchableLink } from "./util.js";
-export default function RuleNoBaseLess() {
+export default function RuleNoDocumentRelative() {
   return defineRule({
     id: "no-baseless",
+    // TODO rename to no-document-relative
     test({ link, fromPath, report }) {
       if (link.startsWith("/") || link.startsWith("http") || isNonFetchableLink(link))
         return;
       report({
         name: "no-baseless",
         scope: "warning",
-        message: "Should not have a base.",
+        message: "Links should be root relative.",
         fix: `${joinURL(fromPath, link)}`,
         fixDescription: `Add base ${fromPath}.`
       });

package/dist/runtime/shared/inspections/no-double-slashes.d.ts

@@ -0,0 +1 @@
+export default function RuleNoDoubleSlashes(): import("../../types").Rule;

package/dist/runtime/shared/inspections/no-double-slashes.js

@@ -0,0 +1,25 @@
+import { defineRule } from "./util.js";
+export default function RuleNoDoubleSlashes() {
+  return defineRule({
+    id: "no-double-slashes",
+    test({ url, link, report }) {
+      if (link.startsWith("//") && !link.includes(".")) {
+        report({
+          name: "no-double-slashes",
+          scope: "warning",
+          message: "Links should not contain double slashes.",
+          fix: link.replaceAll(/(^\/{2,}|\/{2,})/g, "/"),
+          fixDescription: "Remove double slashes."
+        });
+      } else if (url.pathname.match(/(^\/{2,}|\/{2,})/)) {
+        report({
+          name: "no-double-slashes",
+          scope: "warning",
+          message: "Links should not contain double slashes.",
+          fix: link.replace(url.pathname, url.pathname.replaceAll(/(^\/{2,}|\/{2,})/g, "/")),
+          fixDescription: "Remove double slashes."
+        });
+      }
+    }
+  });
+}

package/dist/runtime/shared/inspections/no-duplicate-query-params.d.ts

@@ -0,0 +1 @@
+export default function RuleNoDuplicateQueryParams(): import("../../types").Rule;

package/dist/runtime/shared/inspections/no-duplicate-query-params.js

@@ -0,0 +1,28 @@
+import { defineRule } from "./util.js";
+export default function RuleNoDuplicateQueryParams() {
+  return defineRule({
+    id: "no-duplicate-query-params",
+    test({ report, link, url }) {
+      if (!url.search)
+        return;
+      const search = url.search.slice(1);
+      const searchParams = search.split("&").map((param) => param.split("=")[0]);
+      const duplicates = /* @__PURE__ */ new Set();
+      for (const param of searchParams) {
+        if (duplicates.has(param)) {
+          const fix = link.replace(new RegExp(`([?&])${param}=[^&]*&?`), "$1");
+          report({
+            name: "no-duplicate-query-params",
+            scope: "warning",
+            message: "Links should not contain duplicated query parameters.",
+            fix,
+            tip: "Duplicate query parameters can cause canonical URL issues.",
+            fixDescription: "Remove duplicate query parameter."
+          });
+          return;
+        }
+        duplicates.add(param);
+      }
+    }
+  });
+}

package/dist/runtime/shared/inspections/no-missing-href.d.ts

@@ -0,0 +1 @@
+export default function RuleNoMissingHref(): import("../../types").Rule;

package/dist/runtime/shared/inspections/no-missing-href.js

@@ -0,0 +1,17 @@
+import { defineRule } from "./util.js";
+export default function RuleNoMissingHref() {
+  return defineRule({
+    id: "no-missing-href",
+    test({ report, link, role }) {
+      if (link.trim().length > 0 || role === "button") {
+        return;
+      }
+      report({
+        name: "no-missing-href",
+        scope: "warning",
+        message: "For accessibility and UX anchor tags require a href attribute.",
+        tip: 'Use a button element with type="button" instead if the link is not navigational.'
+      }, true);
+    }
+  });
+}

package/dist/runtime/shared/inspections/no-non-ascii-chars.d.ts

@@ -0,0 +1 @@
+export default function RuleNoNonAsciiChars(): import("../../types").Rule;