@mui/internal-code-infra 0.0.4-canary.40 → 0.0.4-canary.42

package/build/brokenLinksChecker/index.d.mts

@@ -55,6 +55,7 @@ export type CrawlOptions = {
     seedUrls?: string[];
     ignores?: IgnoreRule[];
     htmlValidate?: HtmlValidateOption;
+    verbose?: boolean;
 };
 export type HtmlValidateOverride = {
     path?: (string | RegExp) | (string | RegExp)[];

package/build/eslint/mui/rules/no-presentation-role.d.mts

@@ -0,0 +1,5 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+declare const rule: import('eslint').Rule.RuleModule;
+export default rule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.4-canary.40",
+  "version": "0.0.4-canary.42",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -139,9 +139,9 @@
     "unified-lint-rule": "^3.0.1",
     "unist-util-visit": "^5.1.0",
     "yargs": "^18.0.0",
-    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.36",
+    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.27",
     "@mui/internal-babel-plugin-display-name": "1.0.4-canary.19",
-    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.27"
+    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.36"
   },
   "peerDependencies": {
     "@next/eslint-plugin-next": "*",
@@ -191,7 +191,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "38a586faaccee1b655da0047f227fe82038494e8",
+  "gitSha": "f2b7a9f6b2db57a03f2e16a5bb351f02a55c3e17",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/brokenLinksChecker/crawlWorker.mjs

@@ -160,21 +160,23 @@ if (pageData.status < 200 || pageData.status >= 400) {
     contentType: type,
   }));
 
-  // 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.
+  // HTML validation. Every entry whose path matches contributes to the
+  // page's config: each is registered as a synthetic preset and the page's
+  // root config `extends` them in order. html-validate's own resolution then
+  // merges them, so callers can layer path-specific overrides on top of a
+  // baseline entry without re-stating the baseline rules.
   /** @type {{ pageUrl: string, results: import('html-validate').Result[] } | null} */
   let htmlValidateResults = null;
   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;
-      }
-    }
+    const matchedEntries = options.htmlValidate.filter((entry) =>
+      matchesAnyPattern(pageUrl, entry.path),
+    );
+
+    if (matchedEntries.length > 0) {
+      const overridePresets = Object.fromEntries(
+        matchedEntries.map((entry, index) => [`mui:override-${index}`, entry.config]),
+      );
 
-    if (matchedEntry) {
       const muiHtmlValidateResolver = staticResolver({
         configs: {
           'mui:recommended': {
@@ -184,13 +186,23 @@ if (pageData.status < 200 || pageData.status >= 400) {
               'require-sri': 'off',
             },
           },
+          ...overridePresets,
         },
       });
 
       const htmlValidator = new HtmlValidate(
-        new StaticConfigLoader([muiHtmlValidateResolver], matchedEntry.config),
+        new StaticConfigLoader([muiHtmlValidateResolver], {
+          extends: Object.keys(overridePresets),
+        }),
       );
 
+      if (options.verbose) {
+        const resolved = await htmlValidator.getConfigFor(pageUrl);
+        console.warn(
+          `[html-validate config] ${pageUrl}\n${JSON.stringify(resolved.getConfigData(), null, 2)}`,
+        );
+      }
+
       const report = await htmlValidator.validateString(rawContent, pageUrl);
       htmlValidateResults = { pageUrl, results: report.results };
     }

package/src/brokenLinksChecker/index.mjs

@@ -351,7 +351,8 @@ 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 {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.
+ * @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 — every entry whose `path` matches the page URL contributes to the merged config (later entries win on conflicting rule keys); an entry without `path` matches every page (use as a baseline and layer more specific overrides on top). If no entry matches, the page is not validated.
+ * @property {boolean} [verbose] - Log extra diagnostics during crawling (e.g. resolved html-validate config per page). Defaults to `false`.
  */
 
 /**
@@ -449,6 +450,7 @@ function resolveOptions(rawOptions) {
     seedUrls: rawOptions.seedUrls ?? ['/'],
     ignores: normalizedIgnores,
     htmlValidate: resolveHtmlValidateConfig(rawOptions.htmlValidate),
+    verbose: rawOptions.verbose ?? false,
   };
 }
 

package/src/brokenLinksChecker/index.test.ts

@@ -62,19 +62,14 @@ describe('Broken Links Checker', () => {
         // Test href-only rule (matches from any page) - note: matches the actual href value
         { href: 'broken-relative.html' },
       ],
-      // 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`.
+      // Exercise the array form with union semantics: every matching entry
+      // contributes to the page's config. The baseline entry (no `path`)
+      // turns off `no-raw-characters` everywhere; the path-specific entry
+      // turns off `no-dup-id` only on /invalid-html.html. Both rules are
+      // silenced on that page because the configs are merged, not replaced.
       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' } } },
+        { path: '/invalid-html.html', config: { rules: { 'no-dup-id': 'off' } } },
       ],
     });
 
@@ -281,31 +276,16 @@ describe('Broken Links Checker', () => {
     expect(result.pages.get('/example.md')?.contentType).toBe('text/markdown');
     expect(result.pages.get('/')?.contentType).toBe('text/html');
 
-    // Test htmlValidate: invalid-html.html has duplicate IDs which should be reported
+    // Test htmlValidate union semantics: invalid-html.html has both a duplicate
+    // ID (no-dup-id) and a raw `&` (no-raw-characters). The path-specific
+    // entry silences no-dup-id; the baseline entry silences no-raw-characters.
+    // Under union semantics both apply, so the page reports zero issues.
     const htmlValidateIssues = result.issues.filter(
       (issue): issue is HtmlValidateIssue => issue.type === 'html-validate',
     );
     const invalidHtmlIssues = htmlValidateIssues.filter(
       (issue) => issue.pageUrl === '/invalid-html.html',
     );
-    expect(invalidHtmlIssues.length).toBeGreaterThan(0);
-    expect(invalidHtmlIssues).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          type: 'html-validate',
-          pageUrl: '/invalid-html.html',
-          ruleId: 'no-dup-id',
-        }),
-      ]),
-    );
-
-    // Test htmlValidate override: no-raw-characters is off, so raw & should NOT be reported
-    expect(invalidHtmlIssues).not.toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          ruleId: 'no-raw-characters',
-        }),
-      ]),
-    );
+    expect(invalidHtmlIssues).toEqual([]);
   }, 30000);
 });

package/src/eslint/mui/config.mjs

@@ -421,6 +421,7 @@ export function createCoreConfig(options = {}) {
         'mui/consistent-production-guard': 'error',
         'mui/add-undef-to-optional': 'off',
         'mui/flatten-parentheses': 'warn',
+        'mui/no-presentation-role': 'off',
 
         'react-hooks/exhaustive-deps': [
           'error',

package/src/eslint/mui/index.mjs

@@ -12,6 +12,7 @@ import rulesOfUseThemeVariants from './rules/rules-of-use-theme-variants.mjs';
 import straightQuotes from './rules/straight-quotes.mjs';
 import addUndefToOptional from './rules/add-undef-to-optional.mjs';
 import flattenParentheses from './rules/flatten-parentheses.mjs';
+import noPresentationRole from './rules/no-presentation-role.mjs';
 
 /** @type {import('eslint').ESLint.Plugin} */
 const muiPlugin = {
@@ -35,6 +36,7 @@ const muiPlugin = {
     // Some discrepancies between TypeScript and ESLint types - casting to any
     'add-undef-to-optional': /** @type {any} */ (addUndefToOptional),
     'flatten-parentheses': /** @type {any} */ (flattenParentheses),
+    'no-presentation-role': noPresentationRole,
   },
 };
 

package/src/eslint/mui/rules/no-presentation-role.mjs

@@ -0,0 +1,60 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const rule = {
+  meta: {
+    docs: {
+      description:
+        'Disallow role="presentation" in favor of role="none". Both are equivalent, but role="none" is clearer and shorter.',
+    },
+    messages: {
+      noPresentation:
+        'Use role="none" instead of role="presentation". They are equivalent, but role="none" is preferred.',
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: [],
+  },
+  create(context) {
+    return {
+      /** @param {import('estree-jsx').JSXAttribute} node */
+      JSXAttribute(node) {
+        if (node.name.type !== 'JSXIdentifier' || node.name.name !== 'role') {
+          return;
+        }
+
+        const { value } = node;
+
+        // role="presentation"
+        if (value !== null && value.type === 'Literal' && value.value === 'presentation') {
+          context.report({
+            node,
+            messageId: 'noPresentation',
+            fix(fixer) {
+              return fixer.replaceText(value, '"none"');
+            },
+          });
+          return;
+        }
+
+        // role={'presentation'}
+        if (
+          value !== null &&
+          value.type === 'JSXExpressionContainer' &&
+          value.expression.type === 'Literal' &&
+          value.expression.value === 'presentation'
+        ) {
+          context.report({
+            node,
+            messageId: 'noPresentation',
+            fix(fixer) {
+              return fixer.replaceText(value, '"none"');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/eslint/mui/rules/no-presentation-role.test.mjs

@@ -0,0 +1,33 @@
+import eslint from 'eslint';
+import parser from '@typescript-eslint/parser';
+import rule from './no-presentation-role.mjs';
+
+const ruleTester = new eslint.RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaFeatures: { jsx: true },
+    },
+  },
+});
+
+ruleTester.run('no-presentation-role', rule, {
+  valid: ['<div role="none" />', '<div role="button" />', '<div />', '<div role={presentation} />'],
+  invalid: [
+    {
+      code: '<div role="presentation" />',
+      errors: [{ messageId: 'noPresentation' }],
+      output: '<div role="none" />',
+    },
+    {
+      code: "<div role={'presentation'} />",
+      errors: [{ messageId: 'noPresentation' }],
+      output: '<div role="none" />',
+    },
+    {
+      code: '<table role="presentation"><tr><td /></tr></table>',
+      errors: [{ messageId: 'noPresentation' }],
+      output: '<table role="none"><tr><td /></tr></table>',
+    },
+  ],
+});