@mui/internal-code-infra 0.0.4-canary.37 → 0.0.4-canary.39

package/build/brokenLinksChecker/index.d.mts

@@ -54,11 +54,20 @@ export type CrawlOptions = {
     concurrency?: number;
     seedUrls?: string[];
     ignores?: IgnoreRule[];
-    htmlValidate?: boolean | import('html-validate').ConfigData;
+    htmlValidate?: HtmlValidateOption;
+};
+export type HtmlValidateOverride = {
+    path?: (string | RegExp) | (string | RegExp)[];
+    config: true | import('html-validate').ConfigData;
+};
+export type HtmlValidateOption = boolean | import('html-validate').ConfigData | HtmlValidateOverride[];
+export type ResolvedHtmlValidateEntry = {
+    path: (string | RegExp)[] | undefined;
+    config: import('html-validate').ConfigData;
 };
 export type ResolvedCrawlOptions = Omit<Required<CrawlOptions>, 'ignores' | 'htmlValidate'> & {
     ignores: NormalizedIgnoreRule[];
-    htmlValidate: import('html-validate').ConfigData | null;
+    htmlValidate: ResolvedHtmlValidateEntry[];
 };
 export type BrokenLinkIssue = {
     type: 'broken-link' | 'broken-target';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.4-canary.37",
+  "version": "0.0.4-canary.39",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -168,7 +168,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "4adceb8de477f1548dbab699a336c2c27a4678c9",
+  "gitSha": "f49ed5478f1a68caa26733b9f33e8d9f8a1a5e6a",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/brokenLinksChecker/crawlWorker.mjs

@@ -12,6 +12,23 @@ import rehypeStringify from 'rehype-stringify';
 /** @type {import('./index.mjs').CrawlWorkerInput} */
 const { pageUrl, options } = workerData;
 
+/**
+ * Tests if a value matches any of the patterns in the array.
+ * Returns true if patterns is undefined/empty (wildcard behavior).
+ * Strings use exact match, RegExp uses .test().
+ * @param {string} value
+ * @param {(string | RegExp)[] | undefined} patterns
+ * @returns {boolean}
+ */
+function matchesAnyPattern(value, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return true;
+  }
+  return patterns.some((pattern) =>
+    typeof pattern === 'string' ? value === pattern : pattern.test(value),
+  );
+}
+
 /**
  * Posts the crawl result back to the parent thread.
  * @param {import('./index.mjs').CrawlWorkerOutput} output
@@ -143,28 +160,38 @@ if (pageData.status < 200 || pageData.status >= 400) {
     contentType: type,
   }));
 
-  // HTML validation
+  // HTML validation. Walk every entry and remember the last one whose path
+  // matches the current page — last match wins, so callers can layer
+  // specific overrides after a default entry.
   /** @type {{ pageUrl: string, results: import('html-validate').Result[] } | null} */
   let htmlValidateResults = null;
-  if (options.htmlValidate && type === 'text/html') {
-    const muiHtmlValidateResolver = staticResolver({
-      configs: {
-        'mui:recommended': {
-          extends: ['html-validate:standard', 'html-validate:document', 'html-validate:browser'],
-          rules: {
-            // TODO: Enable when subresource integrity is adopted across projects
-            'require-sri': 'off',
+  if (type === 'text/html' && options.htmlValidate.length > 0) {
+    /** @type {import('./index.mjs').ResolvedHtmlValidateEntry | null} */
+    let matchedEntry = null;
+    for (const entry of options.htmlValidate) {
+      if (matchesAnyPattern(pageUrl, entry.path)) {
+        matchedEntry = entry;
+      }
+    }
+
+    if (matchedEntry) {
+      const muiHtmlValidateResolver = staticResolver({
+        configs: {
+          'mui:recommended': {
+            extends: ['html-validate:standard', 'html-validate:document', 'html-validate:browser'],
+            rules: {
+              // TODO: Enable when subresource integrity is adopted across projects
+              'require-sri': 'off',
+            },
           },
         },
-      },
-    });
+      });
 
-    const htmlValidator = new HtmlValidate(
-      new StaticConfigLoader([muiHtmlValidateResolver], options.htmlValidate),
-    );
+      const htmlValidator = new HtmlValidate(
+        new StaticConfigLoader([muiHtmlValidateResolver], matchedEntry.config),
+      );
 
-    const report = await htmlValidator.validateString(rawContent, pageUrl);
-    if (!report.valid) {
+      const report = await htmlValidator.validateString(rawContent, pageUrl);
       htmlValidateResults = { pageUrl, results: report.results };
     }
   }

package/src/brokenLinksChecker/index.mjs

@@ -351,12 +351,29 @@ function shouldIgnoreLink(link, ignores) {
  * @property {number} [concurrency] - Number of concurrent page fetches (defaults to 4)
  * @property {string[]} [seedUrls] - Starting URLs for the crawl (defaults to ['/'])
  * @property {IgnoreRule[]} [ignores] - Rules to ignore broken links. Each rule can have path, href, contentType, and/or has properties. All specified properties must match (AND logic). Within a property, multiple values use OR logic.
- * @property {boolean | import('html-validate').ConfigData} [htmlValidate] - Enable HTML validation on crawled pages. `false` (default): disabled. `true`: validate with recommended rules. Object: use as html-validate config (supports `extends: ['mui:recommended']` to reference the default config).
+ * @property {HtmlValidateOption} [htmlValidate] - Enable HTML validation on crawled pages. `false` (default): disabled. `true`: validate with recommended rules. Object: use as html-validate config — `extends` defaults to `['mui:recommended']` when omitted, so most callers only need to set `rules`. Array: per-path config overrides — entries are walked in order and the **last** entry whose `path` matches the page URL wins; an entry without `path` matches every page (use as a default and put more specific overrides after it). If no entry matches, the page is not validated.
+ */
+
+/**
+ * Per-page HTML validation override entry.
+ * @typedef {Object} HtmlValidateOverride
+ * @property {(string | RegExp) | (string | RegExp)[]} [path] - Pattern(s) to match the page URL. Strings use exact match. Omit to match every page.
+ * @property {true | import('html-validate').ConfigData} config - html-validate config (or `true` for `mui:recommended`).
+ */
+
+/**
+ * Public shape of the htmlValidate option.
+ * @typedef {boolean | import('html-validate').ConfigData | HtmlValidateOverride[]} HtmlValidateOption
+ */
+
+/**
+ * Resolved per-page HTML validation entry. Empty array means validation is disabled.
+ * @typedef {{ path: (string | RegExp)[] | undefined, config: import('html-validate').ConfigData }} ResolvedHtmlValidateEntry
  */
 
 /**
  * Fully resolved configuration with all optional fields filled with defaults.
- * @typedef {Omit<Required<CrawlOptions>, 'ignores' | 'htmlValidate'> & { ignores: NormalizedIgnoreRule[], htmlValidate: import('html-validate').ConfigData | null }} ResolvedCrawlOptions
+ * @typedef {Omit<Required<CrawlOptions>, 'ignores' | 'htmlValidate'> & { ignores: NormalizedIgnoreRule[], htmlValidate: ResolvedHtmlValidateEntry[] }} ResolvedCrawlOptions
  */
 
 /**
@@ -373,18 +390,37 @@ function validateIgnoreRule(rule) {
 }
 
 /**
- * Resolves the htmlValidate option into an html-validate config object or null.
- * @param {boolean | import('html-validate').ConfigData | undefined} option
- * @returns {import('html-validate').ConfigData | null}
+ * Normalizes a single config value to a non-null html-validate config object.
+ * Defaults `extends` to `['mui:recommended']` when the caller did not provide
+ * one, so overrides typically only need to specify the `rules` they want to
+ * change. To opt out of the default, pass `extends: []` explicitly.
+ * @param {true | import('html-validate').ConfigData} config
+ * @returns {import('html-validate').ConfigData}
+ */
+function normalizeHtmlValidateConfig(config) {
+  if (config === true) {
+    return { extends: ['mui:recommended'] };
+  }
+  return { extends: ['mui:recommended'], ...config };
+}
+
+/**
+ * Resolves the htmlValidate option into an array of per-page entries.
+ * An empty array means validation is disabled.
+ * @param {HtmlValidateOption | undefined} option
+ * @returns {ResolvedHtmlValidateEntry[]}
  */
 function resolveHtmlValidateConfig(option) {
   if (!option) {
-    return null;
+    return [];
   }
-  if (option === true) {
-    return { extends: ['mui:recommended'] };
+  if (option === true || !Array.isArray(option)) {
+    return [{ path: undefined, config: normalizeHtmlValidateConfig(option) }];
   }
-  return option;
+  return option.map((entry) => ({
+    path: normalizeToArray(entry.path),
+    config: normalizeHtmlValidateConfig(entry.config),
+  }));
 }
 
 /**
@@ -796,7 +832,7 @@ export async function crawl(rawOptions) {
   console.log(`  Total broken links: ${chalk.cyan(fmt(brokenLinks))}`);
   console.log(`  Total broken link targets: ${chalk.cyan(fmt(brokenLinkTargets))}`);
   console.log(`  Total ignored: ${chalk.cyan(fmt(ignoredCount))}`);
-  if (options.htmlValidate) {
+  if (options.htmlValidate.length > 0) {
     const pagesWithHtmlIssues = new Set(htmlValidateIssues.map((issue) => issue.pageUrl)).size;
     console.log(
       `  HTML validation issues: ${chalk.cyan(fmt(htmlValidateIssues.length))} across ${chalk.cyan(fmt(pagesWithHtmlIssues))} ${pagesWithHtmlIssues === 1 ? 'page' : 'pages'}`,

package/src/brokenLinksChecker/index.test.ts

@@ -62,12 +62,20 @@ describe('Broken Links Checker', () => {
         // Test href-only rule (matches from any page) - note: matches the actual href value
         { href: 'broken-relative.html' },
       ],
-      htmlValidate: {
-        extends: ['mui:recommended'],
-        rules: {
-          'no-raw-characters': 'off',
+      // Exercise the array form. Three entries all match /invalid-html.html;
+      // the last one wins, so its rules apply (no-dup-id ON, no-raw-characters
+      // OFF). The middle entry's `no-dup-id: off` is shadowed by the regex
+      // entry below it, demonstrating last-match-wins. The default entry
+      // applies to every other page (markdown, etc.) since the regex only
+      // matches `.html`.
+      htmlValidate: [
+        { config: { rules: { 'no-raw-characters': 'off' } } },
+        {
+          path: '/invalid-html.html',
+          config: { rules: { 'no-dup-id': 'off', 'no-raw-characters': 'off' } },
         },
-      },
+        { path: /\.html$/, config: { rules: { 'no-raw-characters': 'off' } } },
+      ],
     });
 
     expect(result.links).toHaveLength(67);