radiant-docs-validator 0.1.14 → 0.1.16

package/dist/index.js

@@ -161,6 +161,13 @@ function readStaticProps(node, componentName, sourceFile) {
         sourceFile
       );
     }
+    if (Object.prototype.hasOwnProperty.call(props, attribute.name)) {
+      componentError(
+        componentName,
+        `Duplicate prop "${attribute.name}" is not supported`,
+        sourceFile
+      );
+    }
     if (attribute.value === null) {
       props[attribute.name] = true;
     } else if (typeof attribute.value === "string") {
@@ -390,6 +397,12 @@ function validateImage(props, options) {
     options.validateAssetHref?.(props.src);
   } else if (typeof props.src === "object") {
     assertPlainObject("Image", "src", props.src, options.sourceFile);
+    assertNoUnknownProps(
+      "Image.src",
+      props.src,
+      ["light", "dark"],
+      options.sourceFile
+    );
     const light = props.src.light;
     const dark = props.src.dark;
     if (typeof light !== "string" || light.trim().length === 0) {
@@ -406,8 +419,15 @@ function validateImage(props, options) {
         options.sourceFile
       );
     }
+    if (typeof dark === "string" && dark.trim().length === 0) {
+      componentError(
+        "Image",
+        'Invalid prop "src.dark": expected a non-empty string',
+        options.sourceFile
+      );
+    }
     options.validateAssetHref?.(light);
-    if (typeof dark === "string" && dark.trim().length > 0) {
+    if (typeof dark === "string") {
       options.validateAssetHref?.(dark);
     }
   }
@@ -422,17 +442,22 @@ function validateRadiantComponentProps(componentName, props, options) {
     "Image",
     "Columns",
     "Column",
+    "Tabs",
+    "Steps",
+    "AccordionGroup",
     "CodeGroup",
     "ComponentPreview"
   ].includes(componentName)) {
     return;
   }
   if (componentName === "Step") {
+    assertNoUnknownProps("Step", props, ["title"], options.sourceFile);
     assertRequired("Step", "title", props.title, options.sourceFile);
     assertType("Step", "title", props.title, ["string"], options.sourceFile);
     return;
   }
   if (componentName === "Tab") {
+    assertNoUnknownProps("Tab", props, ["label", "icon"], options.sourceFile);
     assertRequired("Tab", "label", props.label, options.sourceFile);
     assertType("Tab", "label", props.label, ["string"], options.sourceFile);
     assertType("Tab", "icon", props.icon, ["string"], options.sourceFile);
@@ -440,6 +465,12 @@ function validateRadiantComponentProps(componentName, props, options) {
     return;
   }
   if (componentName === "Accordion") {
+    assertNoUnknownProps(
+      "Accordion",
+      props,
+      ["title", "icon", "defaultOpen", "titleSize"],
+      options.sourceFile
+    );
     assertRequired("Accordion", "title", props.title, options.sourceFile);
     assertType("Accordion", "title", props.title, ["string"], options.sourceFile);
     assertType("Accordion", "icon", props.icon, ["string"], options.sourceFile);
@@ -455,6 +486,12 @@ function validateRadiantComponentProps(componentName, props, options) {
     return;
   }
   if (componentName === "Callout") {
+    assertNoUnknownProps(
+      "Callout",
+      props,
+      ["type", "title", "icon", "accent", "color"],
+      options.sourceFile
+    );
     assertEnum(
       "Callout",
       "type",
@@ -467,6 +504,9 @@ function validateRadiantComponentProps(componentName, props, options) {
     validateIconProp("Callout", "icon", props.icon, options);
     assertType("Callout", "accent", props.accent, ["boolean"], options.sourceFile);
     assertType("Callout", "color", props.color, ["string"], options.sourceFile);
+    if (props.color !== void 0) {
+      assertHexColor("Callout", "color", props.color, options.sourceFile);
+    }
     if (props.title === true) {
       componentError("Callout", 'Invalid prop "title": expected string or false, got true', options.sourceFile);
     }
@@ -483,6 +523,18 @@ function validateRadiantComponentProps(componentName, props, options) {
     validateImage(props, options);
     return;
   }
+  if (componentName === "Tabs") {
+    assertNoUnknownProps("Tabs", props, [], options.sourceFile);
+    return;
+  }
+  if (componentName === "Steps") {
+    assertNoUnknownProps("Steps", props, [], options.sourceFile);
+    return;
+  }
+  if (componentName === "AccordionGroup") {
+    assertNoUnknownProps("AccordionGroup", props, [], options.sourceFile);
+    return;
+  }
   if (componentName === "Columns") {
     assertNoUnknownProps("Columns", props, ["columns"], options.sourceFile);
     assertType("Columns", "columns", props.columns, ["number", "string"], options.sourceFile);
@@ -693,6 +745,16 @@ function configureDocsValidator({
   lastMtime = 0;
 }
 var iconSets = /* @__PURE__ */ new Map();
+var LOCAL_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".svg",
+  ".webp"
+]);
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -747,14 +809,19 @@ function validateIcon(icon, currentPath) {
     }
     return;
   }
-  const localRelativePath = icon.startsWith("/") ? icon.slice(1) : icon;
-  const localPath = path.join(DOCS_DIR, localRelativePath);
-  if (!fs.existsSync(localPath)) {
+  const localRelativePath = validateLocalDocsFile(
+    icon,
+    currentPath,
+    "Icon"
+  );
+  const extension = path.extname(localRelativePath).toLowerCase();
+  if (!LOCAL_IMAGE_EXTENSIONS.has(extension)) {
     throwConfigError(
-      `Icon not found: "${icon}". Local icons must exist in your repository. Did you mean to use an library icon like "lucide:home"?`,
+      `Icon must be a valid image file (.svg, .png, .jpg, .jpeg, .webp, .gif, .ico, .avif). Found: ${icon}`,
       currentPath
     );
   }
+  return;
 }
 function validateComponentIcon(icon, currentPath) {
   const trimmedIcon = icon.trim();
@@ -806,13 +873,25 @@ var throwConfigError = (message, currentPath) => {
   throw new Error(`${message}${location}
 `);
 };
+function assertNoUnknownKeys(value, allowedKeys, currentPath, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      throwConfigError(
+        `${label} does not support '${key}'. Supported keys: ${allowedKeys.join(", ")}.`,
+        [...currentPath, key]
+      );
+    }
+  }
+}
 function checkType(value, type, currentPath, label) {
-  if (value === void 0 || value === null) return;
+  if (value === void 0) return;
   if (type === "array") {
     if (!Array.isArray(value))
       throwConfigError(`${label} must be an array.`, currentPath);
   } else if (type === "object") {
-    if (typeof value !== "object" || value === null)
+    if (typeof value !== "object" || value === null || Array.isArray(value))
       throwConfigError(`${label} must be an object.`, currentPath);
   } else {
     if (typeof value !== type)
@@ -946,8 +1025,13 @@ function normalizeSeedValue(value, currentPath, label) {
   return trimmedValue;
 }
 function validateFileExistence(filePath, currentPath) {
-  const fullPath = path.join(DOCS_DIR, `${filePath}.mdx`);
-  if (!fs.existsSync(fullPath)) {
+  const normalizedPath = normalizeLocalDocsPath(
+    `${filePath}.mdx`,
+    currentPath,
+    "Page path"
+  );
+  const fullPath = path.join(DOCS_DIR, normalizedPath);
+  if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
     throwConfigError(
       `Referenced file not found. Expected: ${filePath}`,
       currentPath
@@ -979,12 +1063,90 @@ function normalizeDocsPagePath(value, currentPath, label = "Page path") {
       currentPath
     );
   }
-  const normalizedPath = trimmedPath.replace(/^\/+/, "").replace(/\/+$/, "");
+  const slashPath = trimmedPath.replace(/\\/g, "/");
+  if (containsPathTraversal(slashPath)) {
+    throwConfigError(
+      `${label} cannot contain '..' path traversal segments`,
+      currentPath
+    );
+  }
+  const normalizedPath = slashPath.replace(/^\/+/, "").replace(/\/+$/, "");
   if (normalizedPath === "") {
     throwConfigError(`${label} cannot be '/'`, currentPath);
   }
   return normalizedPath;
 }
+function normalizeLocalDocsPath(value, currentPath, label) {
+  const trimmedPath = value.trim();
+  if (trimmedPath.length === 0) {
+    throwConfigError(`${label} cannot be empty.`, currentPath);
+  }
+  if (trimmedPath.startsWith("#") || trimmedPath.startsWith("?") || trimmedPath.startsWith("//")) {
+    throwConfigError(`${label} must be a local file path in the docs root.`, currentPath);
+  }
+  const { pathname } = splitHrefPathAndSuffix(trimmedPath);
+  const slashPath = pathname.replace(/\\/g, "/");
+  if (containsPathTraversal(slashPath)) {
+    throwConfigError(
+      `${label} cannot contain '..' path traversal segments.`,
+      currentPath
+    );
+  }
+  const withoutLeadingSlash = slashPath.replace(/^\/+/, "");
+  const normalizedPath = path.posix.normalize(`/${withoutLeadingSlash}`).replace(/^\/+/, "");
+  if (!normalizedPath || normalizedPath === ".") {
+    throwConfigError(`${label} cannot be '/'.`, currentPath);
+  }
+  const fullPath = path.resolve(DOCS_DIR, normalizedPath);
+  const relativePath = path.relative(DOCS_DIR, fullPath);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    throwConfigError(`${label} must stay inside the docs root.`, currentPath);
+  }
+  return normalizedPath;
+}
+function getSvgValidationError(fullPath, label) {
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, "utf-8");
+  } catch (error) {
+    return `${label} could not be read as an SVG file.`;
+  }
+  if (!/<svg(?:\s|>)/i.test(content)) {
+    return `${label} must contain an <svg> element.`;
+  }
+  if (/<script(?:\s|>)/i.test(content)) {
+    return `${label} cannot contain <script> tags.`;
+  }
+  return null;
+}
+function validateLocalFileContents(fullPath, relativePath, currentPath, label) {
+  const stats = fs.statSync(fullPath);
+  if (stats.size === 0) {
+    throwConfigError(
+      `${label} file is empty. Expected a non-empty file: ${relativePath}`,
+      currentPath
+    );
+  }
+  if (path.extname(relativePath).toLowerCase() === ".svg") {
+    const svgError = getSvgValidationError(fullPath, label);
+    if (svgError) {
+      throwConfigError(svgError, currentPath);
+    }
+  }
+}
+function validateLocalDocsFile(value, currentPath, label) {
+  const normalizedPath = normalizeLocalDocsPath(value, currentPath, label);
+  const fullPath = path.join(DOCS_DIR, normalizedPath);
+  if (!fs.existsSync(fullPath)) {
+    throwConfigError(`${label} file not found. Expected: ${normalizedPath}`, currentPath);
+  }
+  const stats = fs.statSync(fullPath);
+  if (!stats.isFile()) {
+    throwConfigError(`${label} file not found. Expected: ${normalizedPath}`, currentPath);
+  }
+  validateLocalFileContents(fullPath, normalizedPath, currentPath, label);
+  return normalizedPath;
+}
 function splitHrefPathAndSuffix(href) {
   const match = href.match(/^([^?#]*)(.*)$/);
   return {
@@ -1046,7 +1208,12 @@ async function loadOpenApiSpec(filePathOrUrl) {
       );
     }
   } else {
-    const fullPath = path.join(DOCS_DIR, filePathOrUrl);
+    const normalizedPath = normalizeLocalDocsPath(
+      filePathOrUrl,
+      [],
+      "OpenAPI file"
+    );
+    const fullPath = path.join(DOCS_DIR, normalizedPath);
     fileContent = fs.readFileSync(fullPath, "utf-8");
   }
   const trimmedContent = fileContent.trim();
@@ -1087,13 +1254,7 @@ async function validateOpenApiFile(filePathOrUrl, currentPath) {
         currentPath
       );
     }
-    const fullPath = path.join(DOCS_DIR, filePathOrUrl);
-    if (!fs.existsSync(fullPath)) {
-      throwConfigError(
-        `Referenced OpenAPI file not found. Expected: ${filePathOrUrl}`,
-        currentPath
-      );
-    }
+    validateLocalDocsFile(filePathOrUrl, currentPath, "OpenAPI file");
   } else {
     try {
       const url = new URL(filePathOrUrl);
@@ -1221,6 +1382,12 @@ function parseEndpointString(endpointStr) {
 }
 async function validateNavOpenApiPage(navOpenApiPage, currentPath) {
   checkType(navOpenApiPage, "object", currentPath, "Open API page");
+  assertNoUnknownKeys(
+    navOpenApiPage,
+    ["source", "endpoint"],
+    currentPath,
+    "Open API page"
+  );
   if (typeof navOpenApiPage.source !== "string") {
     throwConfigError(
       "Open API page must include a 'source' property that is a string.",
@@ -1270,6 +1437,12 @@ async function validateNavigationNode(item, currentPath, groupDepth = 0) {
   }
   if (isGroup) {
     const path2 = [...currentPath];
+    assertNoUnknownKeys(
+      item,
+      ["group", "pages", "icon", "expanded", "tag"],
+      path2,
+      "Navigation group"
+    );
     if (groupDepth >= 2) {
       throwConfigError("Groups can only be nested up to 2 levels deep.", path2);
     }
@@ -1298,6 +1471,12 @@ async function validateNavigationNode(item, currentPath, groupDepth = 0) {
   }
   if (isPage) {
     const path2 = [...currentPath];
+    assertNoUnknownKeys(
+      item,
+      ["page", "icon", "tag", "title"],
+      path2,
+      "Navigation page"
+    );
     const normalizedPagePath = normalizeDocsPagePath(item.page, [
       ...path2,
       "page"
@@ -1318,6 +1497,12 @@ async function validateNavigationNode(item, currentPath, groupDepth = 0) {
   }
   if (isOpenApiPage) {
     const path2 = [...currentPath];
+    assertNoUnknownKeys(
+      item,
+      ["openapi", "title", "tag"],
+      path2,
+      "Open API navigation page"
+    );
     if ("icon" in item) {
       throwConfigError(
         "Open API page items cannot have an 'icon'. Method badges are displayed automatically.",
@@ -1411,6 +1596,12 @@ function getFirstRouteFromNavigation(navigation) {
 }
 async function validateNavOpenApi(navOpenApi, currentPath) {
   checkType(navOpenApi, "object", currentPath, "Open API object");
+  assertNoUnknownKeys(
+    navOpenApi,
+    ["source", "include", "exclude"],
+    currentPath,
+    "Open API object"
+  );
   if (typeof navOpenApi.source !== "string") {
     throwConfigError(
       "Open API object must have an 'source' property that is a string.",
@@ -1506,6 +1697,12 @@ async function validateNavOpenApi(navOpenApi, currentPath) {
 }
 async function validateNavMenuItem(item, currentPath) {
   checkType(item, "object", currentPath, "Menu item");
+  assertNoUnknownKeys(
+    item,
+    ["label", "submenu", "icon"],
+    currentPath,
+    "Menu item"
+  );
   validateIcon(item.icon, [...currentPath, "icon"]);
   if (!item.label) {
     throwConfigError("Menu item must have a 'label' property.", [
@@ -1600,6 +1797,7 @@ async function validateNavMenuItem(item, currentPath) {
 }
 async function validateNavMenu(menu, currentPath) {
   checkType(menu, "object", currentPath, "Menu");
+  assertNoUnknownKeys(menu, ["type", "label", "items"], currentPath, "Menu");
   if (menu.type !== void 0) {
     if (menu.type !== "dropdown" && menu.type !== "segmented") {
       throwConfigError(
@@ -1623,6 +1821,12 @@ async function validateNavMenu(menu, currentPath) {
 function validateNavbarItem(item, currentPath) {
   if (item === void 0) return null;
   checkType(item, "object", currentPath, "Navbar item");
+  assertNoUnknownKeys(
+    item,
+    ["text", "href", "icon", "color"],
+    currentPath,
+    "Navbar item"
+  );
   if (typeof item.text !== "string") {
     throwConfigError("Navbar item must have a 'text' property.", [
       ...currentPath,
@@ -1674,24 +1878,16 @@ function validateLogoPaddingValue(value, currentPath, label) {
   }
 }
 function validateLogoImagePath(imagePath, currentPath, label) {
-  const validExtensions = [".svg", ".png", ".jpg", ".jpeg", ".webp", ".gif"];
-  const hasValidExtension = validExtensions.some(
-    (ext) => imagePath.toLowerCase().endsWith(ext)
-  );
+  const normalizedPath = normalizeLocalDocsPath(imagePath, currentPath, label);
+  const extension = path.extname(normalizedPath).toLowerCase();
+  const hasValidExtension = LOCAL_IMAGE_EXTENSIONS.has(extension);
   if (!hasValidExtension) {
     throwConfigError(
-      `${label} must be a valid image file (.svg, .png, .jpg, .jpeg, .webp, .gif)`,
-      currentPath
-    );
-  }
-  const normalizedPath = imagePath.startsWith("/") ? imagePath.slice(1) : imagePath;
-  const fullPath = path.join(DOCS_DIR, normalizedPath);
-  if (!fs.existsSync(fullPath)) {
-    throwConfigError(
-      `${label} file not found. Expected: ${normalizedPath}`,
+      `${label} must be a valid image file (.svg, .png, .jpg, .jpeg, .webp, .gif, .ico, .avif)`,
       currentPath
     );
   }
+  validateLocalDocsFile(imagePath, currentPath, label);
 }
 function validateAssistantIconSource(iconSource, currentPath) {
   checkType(iconSource, "string", currentPath, "Assistant icon source");
@@ -1740,14 +1936,7 @@ function validateAssistantIconSource(iconSource, currentPath) {
       currentPath
     );
   }
-  const normalizedPath = parsed.pathname.replace(/^\/+/, "");
-  const fullPath = path.join(DOCS_DIR, normalizedPath);
-  if (!fs.existsSync(fullPath)) {
-    throwConfigError(
-      `Assistant icon source file not found. Expected: ${normalizedPath}`,
-      currentPath
-    );
-  }
+  validateLocalDocsFile(parsed.pathname, currentPath, "Assistant icon source");
   return trimmedSource;
 }
 function validateLogoVariant(variant, currentPath, mode) {
@@ -1812,6 +2001,12 @@ function validateLogoVariant(variant, currentPath, mode) {
 function validateLogo(logo) {
   if (logo === void 0) return;
   checkType(logo, "object", ["logo"], "Logo configuration");
+  assertNoUnknownKeys(
+    logo,
+    ["light", "dark", "href", "pill"],
+    ["logo"],
+    "Logo configuration"
+  );
   validateLogoVariant(logo.light, ["logo", "light"], "light");
   validateLogoVariant(logo.dark, ["logo", "dark"], "dark");
   if (logo.href !== void 0) {
@@ -2426,6 +2621,12 @@ function validateNavbar(navbar) {
   const hiddenPageRoutes = [];
   if (navbar === void 0) return hiddenPageRoutes;
   checkType(navbar, "object", ["navbar"], "Navbar configuration");
+  assertNoUnknownKeys(
+    navbar,
+    ["blur", "primary", "secondary", "links"],
+    ["navbar"],
+    "Navbar configuration"
+  );
   checkType(navbar.blur, "boolean", ["navbar", "blur"], "Navbar blur setting");
   const primaryPageRoute = validateNavbarItem(navbar.primary, [
     "navbar",
@@ -2456,6 +2657,12 @@ function validateFooter(footer) {
   const hiddenPageRoutes = [];
   if (footer === void 0) return hiddenPageRoutes;
   checkType(footer, "object", ["footer"], "Footer configuration");
+  assertNoUnknownKeys(
+    footer,
+    ["socials", "links"],
+    ["footer"],
+    "Footer configuration"
+  );
   if (footer.socials !== void 0) {
     checkType(
       footer.socials,
@@ -2509,6 +2716,12 @@ function validateFooter(footer) {
     checkType(footer.links, "array", ["footer", "links"], "Footer links");
     footer.links.forEach((link, i) => {
       checkType(link, "object", ["footer", "links", i], "Footer link");
+      assertNoUnknownKeys(
+        link,
+        ["text", "href"],
+        ["footer", "links", i],
+        "Footer link"
+      );
       if (typeof link.text !== "string") {
         throwConfigError("Footer link must have a 'text' property.", [
           "footer",
@@ -2540,6 +2753,12 @@ function validateFooter(footer) {
 }
 async function validateNavigation(navigation) {
   checkType(navigation, "object", ["navigation"], "Navigation");
+  assertNoUnknownKeys(
+    navigation,
+    ["pages", "menu", "openapi"],
+    ["navigation"],
+    "Navigation"
+  );
   const keys = Object.keys(navigation);
   const validKeys = ["pages", "menu", "openapi"];
   const navKeys = keys.filter((key) => validKeys.includes(key));
@@ -2584,6 +2803,25 @@ async function validateNavigation(navigation) {
   }
 }
 async function validateConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throwConfigError("docs.json must be an object.", []);
+  }
+  assertNoUnknownKeys(
+    config,
+    [
+      "title",
+      "logo",
+      "theme",
+      "assistant",
+      "home",
+      "navigation",
+      "navbar",
+      "playground",
+      "footer"
+    ],
+    [],
+    "docs.json"
+  );
   validateTitle(config.title);
   validateLogo(config.logo);
   validateTheme(config.theme);
@@ -2612,6 +2850,12 @@ async function validateConfig(config) {
   config.hiddenPageRoutes = Array.from(dedupedHiddenPageRoutes.values());
   if (config.playground !== void 0) {
     checkType(config.playground, "object", ["playground"], "Playground");
+    assertNoUnknownKeys(
+      config.playground,
+      ["proxy"],
+      ["playground"],
+      "Playground"
+    );
     if (config.playground.proxy !== void 0) {
       checkType(
         config.playground.proxy,
@@ -2871,16 +3115,38 @@ function validateDocsRootAbsoluteHref(args) {
   }
   if (resolvedHref.kind === "local-asset") {
     const fullAssetPath = path.join(DOCS_DIR, resolvedHref.filePath);
-    if (!fs.existsSync(fullAssetPath) || !fs.statSync(fullAssetPath).isFile()) {
+    if (!fs.existsSync(fullAssetPath)) {
+      throw new Error(
+        `Invalid local asset "${args.href}" in ${args.sourceFile}. No matching file was found. Expected "${resolvedHref.filePath}" under the docs root.`
+      );
+    }
+    const assetStats = fs.statSync(fullAssetPath);
+    if (!assetStats.isFile()) {
       throw new Error(
         `Invalid local asset "${args.href}" in ${args.sourceFile}. No matching file was found. Expected "${resolvedHref.filePath}" under the docs root.`
       );
     }
+    if (assetStats.size === 0) {
+      throw new Error(
+        `Invalid local asset "${args.href}" in ${args.sourceFile}. The referenced file is empty.`
+      );
+    }
     if (!resolvedHref.publishable) {
       throw new Error(
         `Invalid local asset "${args.href}" in ${args.sourceFile}. Files with extension "${resolvedHref.extension}" are not published as docs assets.`
       );
     }
+    if (resolvedHref.extension === ".svg") {
+      const svgError = getSvgValidationError(
+        fullAssetPath,
+        `SVG asset "${args.href}"`
+      );
+      if (svgError) {
+        throw new Error(
+          `Invalid local asset "${args.href}" in ${args.sourceFile}. ${svgError}`
+        );
+      }
+    }
     return;
   }
   if (args.expectedTarget === "asset") {
@@ -2939,12 +3205,15 @@ function createInternalLinkValidationPlugin(args) {
         if (hrefAttribute.name !== "href" && hrefAttribute.name !== "src") {
           continue;
         }
-        if (hrefAttribute.name === "href" && typeof hrefAttribute.value !== "string") {
+        if (typeof hrefAttribute.value !== "string") {
+          if (hrefAttribute.name === "src" && element.name === "Image") {
+            continue;
+          }
+          const example = hrefAttribute.name === "src" ? 'src="/images/example.png"' : 'href="/guides/quickstart"';
           throw new Error(
-            `Invalid JSX href in ${args.sourceFile}. Direct JSX href props must use quoted strings, such as href="/guides/quickstart", not JSX expressions.`
+            `Invalid JSX ${hrefAttribute.name} in ${args.sourceFile}. Direct JSX ${hrefAttribute.name} props must use quoted strings, such as ${example}, not JSX expressions.`
           );
         }
-        if (typeof hrefAttribute.value !== "string") continue;
         validateDocsRootAbsoluteHref({
           href: hrefAttribute.value,
           sourceFile: args.sourceFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "radiant-docs-validator",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Shared validation for Radiant documentation repositories",
   "type": "module",
   "scripts": {