@mui/internal-code-infra 0.0.3-canary.1 → 0.0.3-canary.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.3-canary.1",
+  "version": "0.0.3-canary.10",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "type": "module",
   "license": "MIT",
@@ -14,31 +14,33 @@
     "./package.json": "./package.json",
     "./prettier": "./src/prettier.mjs",
     "./eslint": "./src/eslint/index.mjs",
-    "./babel-config": "./src/babel-config.mjs"
+    "./babel-config": "./src/babel-config.mjs",
+    "./markdownlint": "./src/markdownlint/index.mjs"
   },
   "bin": {
     "code-infra": "./bin/code-infra.mjs"
   },
   "dependencies": {
-    "@argos-ci/core": "^4.1.0",
+    "@argos-ci/core": "^4.1.4",
     "@babel/cli": "^7.28.3",
-    "@babel/core": "^7.28.3",
+    "@babel/core": "^7.28.4",
+    "@babel/plugin-syntax-jsx": "^7.27.1",
     "@babel/plugin-syntax-typescript": "^7.27.1",
     "@babel/plugin-transform-runtime": "^7.28.3",
     "@babel/preset-env": "^7.28.3",
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
     "@eslint/compat": "^1.3.2",
-    "@eslint/js": "^9.34.0",
-    "@next/eslint-plugin-next": "^15.5.0",
+    "@eslint/js": "^9.35.0",
+    "@next/eslint-plugin-next": "^15.5.3",
     "@octokit/auth-action": "^6.0.1",
     "@octokit/rest": "^22.0.0",
-    "@pnpm/find-workspace-dir": "^1000.1.2",
+    "@pnpm/find-workspace-dir": "^1000.1.3",
     "babel-plugin-optimize-clsx": "^2.6.2",
     "babel-plugin-transform-inline-environment-variables": "^0.4.4",
     "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
     "babel-plugin-transform-remove-imports": "^1.8.0",
-    "chalk": "^5.6.0",
+    "chalk": "^5.6.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-module-utils": "^2.12.1",
@@ -48,19 +50,19 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-compiler": "^19.1.0-rc.2",
     "eslint-plugin-react-hooks": "^6.0.0-rc1",
-    "eslint-plugin-testing-library": "^7.6.6",
+    "eslint-plugin-testing-library": "^7.7.0",
     "execa": "^9.6.0",
     "git-url-parse": "^16.1.0",
-    "globals": "^16.3.0",
+    "globals": "^16.4.0",
     "globby": "^14.1.0",
     "lodash-es": "^4.17.21",
     "minimatch": "^10.0.3",
     "semver": "^7.7.2",
-    "typescript-eslint": "^8.40.0",
+    "typescript-eslint": "^8.43.0",
     "yargs": "^18.0.0",
-    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.7",
-    "@mui/internal-babel-plugin-display-name": "1.0.4-canary.6",
-    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.19"
+    "@mui/internal-babel-plugin-display-name": "1.0.4-canary.7",
+    "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.10",
+    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.21"
   },
   "peerDependencies": {
     "eslint": "^9.0.0",
@@ -75,11 +77,11 @@
     "@types/estree-jsx": "^1.0.5",
     "@types/lodash-es": "^4.17.12",
     "@types/yargs": "^17.0.33",
-    "@typescript-eslint/parser": "^8.40.0",
-    "@typescript-eslint/rule-tester": "^8.40.0",
-    "eslint": "^9.34.0",
+    "@typescript-eslint/parser": "^8.43.0",
+    "@typescript-eslint/rule-tester": "^8.43.0",
+    "eslint": "^9.35.0",
     "prettier": "^3.6.2",
-    "typescript-eslint": "^8.40.0"
+    "typescript-eslint": "^8.43.0"
   },
   "files": [
     "bin",
@@ -91,7 +93,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "2159d7ef17d0ea7ff2ba98c5df9f6519fcaccfbe",
+  "gitSha": "b5dcc0b6d364d0474376eda1be73c681ffaaa6f8",
   "scripts": {
     "typescript": "tsc -p tsconfig.json",
     "test": "pnpm -w test --project @mui/internal-code-infra",

package/src/babel-config.mjs

@@ -13,7 +13,7 @@ import pluginRemovePropTypes from 'babel-plugin-transform-react-remove-prop-type
  * @param {boolean} [param0.debug]
  * @param {boolean} [param0.optimizeClsx]
  * @param {boolean} [param0.removePropTypes]
- * @param {boolean} [param0.isTest]
+ * @param {boolean} [param0.noResolveImports]
  * @param {'cjs' | 'esm'} param0.bundle
  * @param {string | null} param0.outExtension - Specify the output file extension.
  * @param {string} param0.runtimeVersion
@@ -23,7 +23,7 @@ export function getBaseConfig({
   debug = false,
   optimizeClsx = false,
   removePropTypes = false,
-  isTest = false,
+  noResolveImports = false,
   bundle,
   runtimeVersion,
   outExtension,
@@ -81,7 +81,7 @@ export function getBaseConfig({
     plugins.push([pluginOptimizeClsx, {}, 'babel-plugin-optimize-clsx']);
   }
 
-  if (bundle === 'esm' && !isTest) {
+  if (bundle === 'esm' && !noResolveImports) {
     plugins.push([
       pluginResolveImports,
       { outExtension },
@@ -119,20 +119,39 @@ export function getBaseConfig({
 }
 
 /**
- * @type {import('@babel/core').ConfigFunction}
+ * @typedef {Object} Options
+ * @prop {'esm' | 'cjs'} [Options.bundle]
+ * @prop {boolean} [Options.noResolveImports]
+ * @prop {undefined} [options.env]
+ */
+
+/**
+ * @param {import('@babel/core').ConfigAPI | Options} api
+ * @returns {import('@babel/core').TransformOptions}
  */
 export default function getBabelConfig(api) {
-  const isStable = api.env(['regressions', 'stable']);
-  const isTest = api.env('test') || process.env.NODE_ENV === 'test';
+  /** @type {'esm' | 'cjs'} */
+  let bundle;
+  /** @type {boolean} */
+  let noResolveImports;
+
+  if (api.env) {
+    // legacy
+    bundle = api.env(['regressions', 'stable']) ? 'esm' : 'cjs';
+    noResolveImports = api.env('test') || process.env.NODE_ENV === 'test';
+  } else {
+    bundle = api.bundle || 'esm';
+    noResolveImports = api.noResolveImports || false;
+  }
 
   return getBaseConfig({
     debug: process.env.MUI_BUILD_VERBOSE === 'true',
-    bundle: isStable ? 'esm' : 'cjs',
+    bundle,
     outExtension: process.env.MUI_OUT_FILE_EXTENSION || null,
     // any package needs to declare 7.25.0 as a runtime dependency. default is ^7.0.0
     runtimeVersion: process.env.MUI_BABEL_RUNTIME_VERSION || '^7.25.0',
     optimizeClsx: process.env.MUI_OPTIMIZE_CLSX === 'true',
     removePropTypes: process.env.MUI_REMOVE_PROP_TYPES === 'true',
-    isTest,
+    noResolveImports,
   });
 }

package/src/cli/babel.mjs

@@ -6,6 +6,7 @@ import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { $ } from 'execa';
+import { BASE_IGNORES } from '../utils/build.mjs';
 
 const TO_TRANSFORM_EXTENSIONS = ['.js', '.ts', '.tsx'];
 
@@ -64,18 +65,6 @@ export async function cjsCopy({ from, to }) {
  * @property {string} [runtimeModule] - The runtime module to replace the errors with.
  */
 
-const BASE_IGNORES = [
-  '**/*.test.js',
-  '**/*.test.ts',
-  '**/*.test.tsx',
-  '**/*.spec.js',
-  '**/*.spec.ts',
-  '**/*.spec.tsx',
-  '**/*.d.ts',
-  '**/*.test/*.*',
-  '**/test-cases/*.*',
-];
-
 /**
  * @param {Object} options
  * @param {boolean} [options.verbose=false] - Whether to enable verbose logging.

package/src/cli/cmdBuild.mjs

@@ -1,9 +1,13 @@
 /* eslint-disable no-console */
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
+import { globby } from 'globby';
 import set from 'lodash-es/set.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs';
+import { sep as posixSep } from 'node:path/posix';
+
+import { getOutExtension, isMjsBuild, mapConcurrently, validatePkgJson } from '../utils/build.mjs';
 
 /**
  * @typedef {Object} Args
@@ -18,6 +22,7 @@ import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs
  * @property {boolean} skipPackageJson - Whether to skip generating the package.json file in the bundle output.
  * @property {boolean} skipMainCheck - Whether to skip checking for main field in package.json.
  * @property {string[]} ignore - Globs to be ignored by Babel.
+ * @property {string[]} [copy] - Files/Directories to be copied. Can be a glob pattern.
  */
 
 const validBundles = [
@@ -298,6 +303,13 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         type: 'boolean',
         default: false,
         description: 'Skip checking for main field in package.json.',
+      })
+      .option('copy', {
+        type: 'string',
+        array: true,
+        description:
+          'Files/Directories to be copied to the output directory. Can be a glob pattern.',
+        default: [],
       });
   },
   async handler(args) {
@@ -442,5 +454,144 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       outputDir: buildDir,
       addTypes: buildTypes,
     });
+
+    await copyHandler({
+      cwd,
+      globs: args.copy ?? [],
+      buildDir,
+      verbose: args.verbose,
+    });
   },
 });
+
+/**
+ * @param {Object} param0
+ * @param {string} param0.cwd - The current working directory.
+ * @param {string[]} [param0.globs=[]] - Extra files to copy, can be specified as `source:target` pairs or just `source`.
+ * @param {string} param0.buildDir - The build directory to copy to.
+ * @param {boolean} [param0.verbose=false] - Whether to suppress output.
+ * @returns {Promise<void>}
+ */
+async function copyHandler({ cwd, globs = [], buildDir, verbose = false }) {
+  /**
+   * @type {(string|{targetPath: string; sourcePath: string})[]}
+   */
+  const defaultFiles = [];
+  const workspaceDir = await findWorkspaceDir(cwd);
+  if (!workspaceDir) {
+    throw new Error('Workspace directory not found');
+  }
+
+  const localOrRootFiles = [
+    [path.join(cwd, 'README.md'), path.join(workspaceDir, 'README.md')],
+    [path.join(cwd, 'LICENSE'), path.join(workspaceDir, 'LICENSE')],
+    [path.join(cwd, 'CHANGELOG.md'), path.join(workspaceDir, 'CHANGELOG.md')],
+  ];
+  await Promise.all(
+    localOrRootFiles.map(async (filesToCopy) => {
+      for (const file of filesToCopy) {
+        if (
+          // eslint-disable-next-line no-await-in-loop
+          await fs.stat(file).then(
+            () => true,
+            () => false,
+          )
+        ) {
+          defaultFiles.push(file);
+          break;
+        }
+      }
+    }),
+  );
+
+  if (globs.length) {
+    const res = globs.map((globPattern) => {
+      const [pattern, baseDir] = globPattern.split(':');
+      return { pattern, baseDir };
+    });
+    /**
+     * Avoids redundant globby calls for the same pattern.
+     *
+     * @type {Map<string, Promise<string[]>>}
+     */
+    const globToResMap = new Map();
+
+    const result = await Promise.all(
+      res.map(async ({ pattern, baseDir }) => {
+        if (!globToResMap.has(pattern)) {
+          const promise = globby(pattern, { cwd });
+          globToResMap.set(pattern, promise);
+        }
+        const files = await globToResMap.get(pattern);
+        return { files: files ?? [], baseDir };
+      }),
+    );
+    globToResMap.clear();
+
+    result.forEach(({ files, baseDir }) => {
+      files.forEach((file) => {
+        const sourcePath = path.resolve(cwd, file);
+        // Use posix separator for the relative paths. So devs can only specify globs with `/` even on Windows.
+        const pathSegments = file.split(posixSep);
+        const relativePath =
+          // Use index 2 (when required) since users can also specify paths like `./src/index.js`
+          pathSegments.slice(pathSegments[0] === '.' ? 2 : 1).join(posixSep) || file;
+        const targetPath = baseDir
+          ? path.resolve(buildDir, baseDir, relativePath)
+          : path.resolve(buildDir, relativePath);
+        defaultFiles.push({ sourcePath, targetPath });
+      });
+    });
+  }
+
+  if (!defaultFiles.length) {
+    if (verbose) {
+      console.log('⓿ No files to copy.');
+    }
+  }
+  await mapConcurrently(
+    defaultFiles,
+    async (file) => {
+      if (typeof file === 'string') {
+        const sourcePath = file;
+        const fileName = path.basename(file);
+        const targetPath = path.join(buildDir, fileName);
+        await recursiveCopy({ source: sourcePath, target: targetPath, verbose });
+      } else {
+        await fs.mkdir(path.dirname(file.targetPath), { recursive: true });
+        await recursiveCopy({ source: file.sourcePath, target: file.targetPath, verbose });
+      }
+    },
+    20,
+  );
+  console.log(`📋 Copied ${defaultFiles.length} files.`);
+}
+
+/**
+ * Recursively copies files and directories from a source path to a target path.
+ *
+ * @async
+ * @param {Object} options - The options for copying files.
+ * @param {string} options.source - The source path to copy from.
+ * @param {string} options.target - The target path to copy to.
+ * @param {boolean} [options.verbose=true] - If true, suppresses console output.
+ * @returns {Promise<boolean>} Resolves when the copy operation is complete.
+ * @throws {Error} Throws if an error occurs other than the source not existing.
+ */
+async function recursiveCopy({ source, target, verbose = true }) {
+  try {
+    await fs.cp(source, target, { recursive: true });
+    if (verbose) {
+      console.log(`Copied ${source} to ${target}`);
+    }
+    return true;
+  } catch (err) {
+    if (/** @type {{ code: string }} */ (err).code !== 'ENOENT') {
+      throw err;
+    }
+    if (verbose) {
+      console.warn(`Source does not exist: ${source}`);
+    }
+    throw err;
+  }
+}

package/src/cli/cmdCopyFiles.mjs

@@ -2,6 +2,7 @@ import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { globby } from 'globby';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { mapConcurrently } from '../utils/build.mjs';
 
 /**
  * @typedef {Object} Args
@@ -105,20 +106,13 @@ async function processGlobs({ globs, cwd, silent = true, buildDir }) {
     });
   });
 
-  const concurrency = filesToProcess.length > 100 ? 100 : filesToProcess.length;
-  const iterator = filesToProcess[Symbol.iterator]();
-  const workers = [];
-  for (let i = 0; i < concurrency; i += 1) {
-    workers.push(
-      Promise.resolve().then(async () => {
-        for (const file of iterator) {
-          // eslint-disable-next-line no-await-in-loop
-          await recursiveCopy({ source: file.sourcePath, target: file.targetPath, silent });
-        }
-      }),
-    );
-  }
-  await Promise.all(workers);
+  await mapConcurrently(
+    filesToProcess,
+    async (file) => {
+      await recursiveCopy({ source: file.sourcePath, target: file.targetPath, silent });
+    },
+    50,
+  );
   return filesToProcess.length;
 }
 

package/src/cli/cmdExtractErrorCodes.mjs

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+
+import { markFn, measureFn } from '../utils/build.mjs';
+
+/**
+ * @typedef {import('../utils/extractErrorCodes.mjs').Args} Args
+ */
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'extract-error-codes',
+  describe: 'Extracts error codes from package(s).',
+  builder(yargs) {
+    return yargs
+      .option('errorCodesPath', {
+        type: 'string',
+        describe: 'The output path to a json file to write the extracted error codes.',
+        demandOption: true,
+      })
+      .option('detection', {
+        type: 'string',
+        describe: 'The detection strategy to use when extracting error codes.',
+        choices: ['opt-in', 'opt-out'],
+        default: 'opt-in',
+      })
+      .option('skip', {
+        type: 'array',
+        describe: 'List of package names to skip.',
+        default: [],
+      });
+  },
+  async handler(args) {
+    const commandName = /** @type {string} */ (args._[0]);
+    await markFn(commandName, async () => {
+      const module = await import('../utils/extractErrorCodes.mjs');
+      await module.default(args);
+    });
+    console.log(
+      `✅ Extracted error codes in ${(measureFn(commandName).duration / 1000.0).toFixed(3)}s`,
+    );
+  },
+});

package/src/cli/cmdJsonLint.mjs

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import fs from 'node:fs/promises';
 import { globby } from 'globby';
 import path from 'node:path';
+import { mapConcurrently } from '../utils/build.mjs';
 
 /**
  * @typedef {Object} Args
@@ -42,33 +43,25 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       followSymbolicLinks: false,
     });
 
-    const fileIterator = filenames[Symbol.iterator]();
-    const concurrency = Math.min(20, filenames.length);
     let passed = true;
-    const workers = [];
 
-    for (let i = 0; i < concurrency; i += 1) {
-      // eslint-disable-next-line @typescript-eslint/no-loop-func
-      const worker = Promise.resolve().then(async () => {
-        for (const filename of fileIterator) {
-          // eslint-disable-next-line no-await-in-loop
-          const content = await fs.readFile(path.join(cwd, filename), { encoding: 'utf8' });
-          try {
-            JSON.parse(content);
-            if (!args.silent) {
-              // eslint-disable-next-line no-console
-              console.log(passMessage(filename));
-            }
-          } catch (error) {
-            passed = false;
-            console.error(failMessage(`Error parsing ${filename}:\n\n${String(error)}`));
+    await mapConcurrently(
+      filenames,
+      async (filename) => {
+        const content = await fs.readFile(path.join(cwd, filename), { encoding: 'utf8' });
+        try {
+          JSON.parse(content);
+          if (!args.silent) {
+            // eslint-disable-next-line no-console
+            console.log(passMessage(filename));
           }
+        } catch (error) {
+          passed = false;
+          console.error(failMessage(`Error parsing ${filename}:\n\n${String(error)}`));
         }
-      });
-      workers.push(worker);
-    }
-
-    await Promise.allSettled(workers);
+      },
+      20,
+    );
     if (!passed) {
       throw new Error('❌ At least one file did not pass. Check the console output');
     }

package/src/cli/index.mjs

@@ -5,6 +5,7 @@ import { hideBin } from 'yargs/helpers';
 import cmdArgosPush from './cmdArgosPush.mjs';
 import cmdBuild from './cmdBuild.mjs';
 import cmdCopyFiles from './cmdCopyFiles.mjs';
+import cmdExtractErrorCodes from './cmdExtractErrorCodes.mjs';
 import cmdJsonLint from './cmdJsonLint.mjs';
 import cmdListWorkspaces from './cmdListWorkspaces.mjs';
 import cmdPublish from './cmdPublish.mjs';
@@ -15,14 +16,16 @@ const pkgJson = createRequire(import.meta.url)('../../package.json');
 
 yargs()
   .scriptName('code-infra')
+  .usage('$0 <command> [args]')
+  .command(cmdArgosPush)
+  .command(cmdBuild)
+  .command(cmdCopyFiles)
+  .command(cmdExtractErrorCodes)
+  .command(cmdJsonLint)
+  .command(cmdListWorkspaces)
   .command(cmdPublish)
   .command(cmdPublishCanary)
-  .command(cmdListWorkspaces)
-  .command(cmdJsonLint)
-  .command(cmdArgosPush)
   .command(cmdSetVersionOverrides)
-  .command(cmdCopyFiles)
-  .command(cmdBuild)
   .demandCommand(1, 'You need at least one command before moving on')
   .strict()
   .help()

package/src/cli/typescript.mjs

@@ -8,6 +8,7 @@ import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { mapConcurrently } from '../utils/build.mjs';
 
 const $$ = $({ stdio: 'inherit' });
 
@@ -27,7 +28,8 @@ export async function emitDeclarations(tsconfig, outDir) {
     --emitDeclarationOnly
     --noEmit false
     --composite false
-    --incremental false`;
+    --incremental false
+    --declarationMap false`;
 }
 
 /**
@@ -80,8 +82,9 @@ async function postProcessDeclarations({ directory }) {
     [pluginRemoveImports, { test: /\.css$/ }],
   ];
 
-  await Promise.all(
-    dtsFiles.map(async (dtsFile) => {
+  await mapConcurrently(
+    dtsFiles,
+    async (dtsFile) => {
       const result = await babel.transformFileAsync(dtsFile, {
         configFile: false,
         plugins: babelPlugins,
@@ -92,7 +95,8 @@ async function postProcessDeclarations({ directory }) {
       } else {
         console.error('failed to transform', dtsFile);
       }
-    }),
+    },
+    20,
   );
 }
 
@@ -107,11 +111,13 @@ async function renameDeclarations({ directory }) {
     return;
   }
   console.log(`Renaming d.ts files to d.mts in ${directory}`);
-  await Promise.all(
-    dtsFiles.map(async (dtsFile) => {
+  await mapConcurrently(
+    dtsFiles,
+    async (dtsFile) => {
       const newFileName = dtsFile.replace(/\.d\.ts$/, '.d.mts');
       await fs.rename(dtsFile, newFileName);
-    }),
+    },
+    20,
   );
 }
 

package/src/eslint/material-ui/config.mjs

@@ -411,7 +411,10 @@ export function createCoreConfig(options = {}) {
         'material-ui/no-styled-box': 'error',
         'material-ui/straight-quotes': 'off',
 
-        'react-hooks/exhaustive-deps': ['error', { additionalHooks: 'useEnhancedEffect' }],
+        'react-hooks/exhaustive-deps': [
+          'error',
+          { additionalHooks: '(useEnhancedEffect|useIsoLayoutEffect)' },
+        ],
         'react-hooks/rules-of-hooks': 'error',
 
         'react/default-props-match-prop-types': [

package/src/markdownlint/duplicate-h1.mjs

@@ -0,0 +1,69 @@
+/**
+ * @typedef {[string, string]} Attr
+ */
+
+/**
+ * @typedef {Object} Token
+ * @property {string} type
+ * @property {string} info
+ * @property {string} tag
+ * @property {string} content
+ * @property {number} lineNumber
+ * @property {Attr[]} attrs
+ */
+
+/**
+ * @typedef {Object} OnErrorObj
+ * @property {number} lineNumber
+ * @property {string} [detail]
+ */
+
+/**
+ * @typedef {(err: OnErrorObj) => void} OnError
+ */
+
+/**
+ * @typedef {Object} MdParams
+ * @property {string} name
+ * @property {string[]} lines
+ * @property {Token[]} tokens
+ */
+
+// This rule is an extension of MD025/no-multiple-top-level-headings.
+// The rule is buggy https://github.com/DavidAnson/markdownlint/pull/1109
+// but also blog headers don't tell you that h1 is already injected.
+export default {
+  names: ['duplicateH1'],
+  description: 'Multiple top-level headings in the same document.',
+  tags: ['headings'],
+  /**
+   * @param {import('./duplicate-h1.mjs').MdParams} params
+   * @param {import('./duplicate-h1.mjs').OnError} onError
+   */
+  function: (params, onError) => {
+    /**
+     * @type {number|boolean}
+     */
+    let hasTopLevelHeading = false;
+    params.tokens.forEach((token) => {
+      if (token.type === 'heading_open' && token.tag === 'h1') {
+        // Avoid duplicate errors with MD025.
+        if (hasTopLevelHeading !== false && hasTopLevelHeading !== 1) {
+          onError({
+            lineNumber: token.lineNumber,
+          });
+        } else if (params.name.includes('/docs/pages/blog/')) {
+          onError({
+            lineNumber: token.lineNumber,
+            detail: 'In the blog, the h1 is already added using the markdown header.title value.',
+          });
+        }
+
+        // Store the first h1 of the page.
+        if (hasTopLevelHeading === false) {
+          hasTopLevelHeading = token.lineNumber;
+        }
+      }
+    });
+  },
+};

package/src/markdownlint/git-diff.mjs

@@ -0,0 +1,31 @@
+export default {
+  names: ['gitDiff'],
+  description: 'Respect the format output of git diff.',
+  tags: ['spaces'],
+  /**
+   * @param {import('./duplicate-h1.mjs').MdParams} params
+   * @param {import('./duplicate-h1.mjs').OnError} onError
+   */
+  function: (params, onError) => {
+    params.tokens.forEach((token) => {
+      if (token.type === 'fence' && token.info === 'diff') {
+        token.content.split('\n').forEach((line, index) => {
+          if (
+            line[0] !== ' ' &&
+            line[0] !== '-' &&
+            line[0] !== '+' &&
+            line !== '' &&
+            line.indexOf('@@ ') !== 0 &&
+            line.indexOf('diff --git ') !== 0 &&
+            line.indexOf('index ') !== 0
+          ) {
+            onError({
+              lineNumber: token.lineNumber + index + 1,
+              detail: `The line start with "+" or "-" or " ": ${line}`,
+            });
+          }
+        });
+      }
+    });
+  },
+};

package/src/markdownlint/index.mjs

@@ -0,0 +1,62 @@
+import straightQuotes from './straight-quotes.mjs';
+import gitDiff from './git-diff.mjs';
+import tableAlignment from './table-alignment.mjs';
+import terminalLanguage from './terminal-language.mjs';
+import duplicateH1 from './duplicate-h1.mjs';
+
+/**
+ * Create a base configuration for markdownlint.
+ * @param {Object} options
+ * @param {(typeof straightQuotes)[]} [options.rules] - An array of custom rules to include.
+ * @param {string[]} [options.ignores] - An array of glob patterns to ignore.
+ * @returns
+ */
+export function createBaseConfig(options = {}) {
+  const { rules = [], ignores = [] } = options;
+  // https://github.com/DavidAnson/markdownlint#rules--aliases
+  return {
+    config: {
+      default: true,
+      MD004: false, // MD004/ul-style. Buggy
+      MD009: {
+        // MD009/no-trailing-spaces
+        br_spaces: 0,
+        strict: true,
+        list_item_empty_lines: false,
+      },
+      MD013: false, // MD013/line-length. Already handled by Prettier.
+      MD014: false, // MD014/commands-show-output. It's OK.
+      MD024: { siblings_only: true }, // MD024/no-duplicate-heading/no-duplicate-header
+      MD025: {
+        // Heading level
+        level: 1,
+        // RegExp for matching title in front matter
+        front_matter_title: '',
+      },
+      MD033: false, // MD033/no-inline-html. We use it from time to time, it's fine.
+      MD034: false, // MD034/no-bare-urls. Not a concern for us, our Markdown interpreter supports it.
+      MD028: false, // MD028/no-blanks-blockquote prevent double blockquote
+      MD029: false, // MD029/ol-prefix. Buggy
+      MD031: false, // MD031/blanks-around-fences Some code blocks inside li
+      MD036: false, // MD036/no-emphasis-as-heading/no-emphasis-as-header. It's OK.
+      MD051: false, // MD051/link-fragments. Many false positives in the changelog.
+      MD052: false, // MD052/reference-links-images. Many false positives in the changelog.
+      MD059: false, // MD059/descriptive-link-text. Does not allow links on text like "link", whereas we redirect to "Link" component.
+      straightQuotes: true,
+      gitDiff: true,
+      tableAlignment: true,
+      terminalLanguage: true,
+      duplicateH1: true,
+    },
+    customRules: [straightQuotes, gitDiff, tableAlignment, terminalLanguage, duplicateH1, ...rules],
+    ignores: [
+      'CHANGELOG.old.md',
+      '**/node_modules/**',
+      '**/build/**',
+      '.github/PULL_REQUEST_TEMPLATE.md',
+      'docs/public/**',
+      'docs/export/**',
+      ...ignores,
+    ],
+  };
+}

package/src/markdownlint/straight-quotes.mjs

@@ -0,0 +1,26 @@
+const nonStraightQuotes = /[‘’“”]/;
+
+export default {
+  names: ['straightQuotes'],
+  description: 'Only allow straight quotes.',
+  tags: ['spelling'],
+  /**
+   * @param {import('./duplicate-h1.mjs').MdParams} params
+   * @param {import('./duplicate-h1.mjs').OnError} onError
+   */
+  function: (params, onError) => {
+    params.lines.forEach((line, lineNumber) => {
+      // It will match
+      // opening single quote: \xE2\x80\x98
+      // closing single quote: \xE2\x80\x99
+      // opening double quote: \xE2\x80\x9C
+      // closing double quote: \xE2\x80\x9D
+      if (nonStraightQuotes.test(line)) {
+        onError({
+          lineNumber: lineNumber + 1,
+          detail: `For line: ${line}`,
+        });
+      }
+    });
+  },
+};

package/src/markdownlint/table-alignment.mjs

@@ -0,0 +1,42 @@
+/**
+ * @param {import('./duplicate-h1.mjs').Attr[]} attrs
+ * @returns {Record<string, string>}
+ */
+function attr(attrs) {
+  return (attrs || []).reduce((acc, item) => ({ ...acc, [item[0]]: item[1] }), {});
+}
+
+export default {
+  names: ['tableAlignment'],
+  description: 'Set table alignment.',
+  tags: ['table'],
+  /**
+   * @param {import('./duplicate-h1.mjs').MdParams} params
+   * @param {import('./duplicate-h1.mjs').OnError} onError
+   */
+  function: (params, onError) => {
+    params.tokens.forEach((token) => {
+      // This is wrong:
+      // | Version | Supported          |
+      // | ------- | ------------------ |
+      //
+      // The second column should be left aligned because it contains text:
+      // | Version | Supported          |
+      // | ------- | :----------------- |
+      //
+      // However, columns that includes numbers should be right aligned:
+      // | Version | Supported          |
+      // | ------: | :----------------- |
+      //
+      // More details: https://ux.stackexchange.com/questions/24066/what-is-the-best-practice-for-data-table-cell-content-alignment
+      //
+      // In this check we expect the style to be 'text-align:right' or equivalent.
+      if (token.type === 'th_open' && attr(token.attrs).style == null) {
+        onError({
+          lineNumber: token.lineNumber,
+          detail: `${params.lines[token.lineNumber - 1]}`,
+        });
+      }
+    });
+  },
+};

package/src/markdownlint/terminal-language.mjs

@@ -0,0 +1,19 @@
+export default {
+  names: ['terminalLanguage'],
+  description: 'Set the right language for terminal code.',
+  tags: ['code'],
+  /**
+   * @param {import('./duplicate-h1.mjs').MdParams} params
+   * @param {import('./duplicate-h1.mjs').OnError} onError
+   */
+  function: (params, onError) => {
+    params.tokens.forEach((token) => {
+      if (token.type === 'fence' && token.info === 'sh') {
+        onError({
+          lineNumber: token.lineNumber,
+          detail: `Use "bash" instead of "sh".`,
+        });
+      }
+    });
+  },
+};

package/src/untyped-plugins.d.ts

@@ -102,6 +102,13 @@ declare module '@babel/plugin-transform-runtime' {
   export default plugin;
 }
 
+declare module '@babel/plugin-syntax-jsx' {
+  import type { PluginItem } from '@babel/core';
+
+  declare const plugin: PluginItem;
+  export default plugin;
+}
+
 declare module '@babel/plugin-syntax-typescript' {
   import type { PluginItem } from '@babel/core';
 

package/src/utils/build.mjs

@@ -68,3 +68,82 @@ export function validatePkgJson(packageJson, options = {}) {
     throw error;
   }
 }
+
+/**
+ * Marks the start and end of a function execution for performance measurement.
+ * Uses the Performance API to create marks and measure the duration.
+ * @function
+ * @template {() => Promise<any>} F
+ * @param {string} label
+ * @param {() => ReturnType<F>} fn
+ * @returns {Promise<ReturnType<F>>}
+ */
+export async function markFn(label, fn) {
+  const startMark = `${label}-start`;
+  const endMark = `${label}-end`;
+  performance.mark(startMark);
+  const result = await fn();
+  performance.mark(endMark);
+  performance.measure(label, startMark, endMark);
+  return result;
+}
+
+/**
+ * @param {string} label
+ */
+export function measureFn(label) {
+  const startMark = `${label}-start`;
+  const endMark = `${label}-end`;
+  return performance.measure(label, startMark, endMark);
+}
+
+export const BASE_IGNORES = [
+  '**/*.test.js',
+  '**/*.test.ts',
+  '**/*.test.tsx',
+  '**/*.spec.js',
+  '**/*.spec.ts',
+  '**/*.spec.tsx',
+  '**/*.d.ts',
+  '**/*.test/*.*',
+  '**/test-cases/*.*',
+];
+
+/**
+ * A utility to map a function over an array of items in a worker pool.
+ *
+ * This function will create a pool of workers and distribute the items to be processed among them.
+ * Each worker will process items sequentially, but multiple workers will run in parallel.
+ *
+ * @function
+ * @template T
+ * @template R
+ * @param {T[]} items
+ * @param {(item: T) => Promise<R>} mapper
+ * @param {number} concurrency
+ * @returns {Promise<(R|Error)[]>}
+ */
+export async function mapConcurrently(items, mapper, concurrency) {
+  if (!items.length) {
+    return Promise.resolve([]); // nothing to do
+  }
+  const itemIterator = items.entries();
+  const count = Math.min(concurrency, items.length);
+  const workers = [];
+  /**
+   * @type {(R|Error)[]}
+   */
+  const results = new Array(items.length);
+  for (let i = 0; i < count; i += 1) {
+    const worker = Promise.resolve().then(async () => {
+      for (const [index, item] of itemIterator) {
+        // eslint-disable-next-line no-await-in-loop
+        const res = await mapper(item);
+        results[index] = res;
+      }
+    });
+    workers.push(worker);
+  }
+  await Promise.all(workers);
+  return results;
+}

package/src/utils/extractErrorCodes.mjs

@@ -0,0 +1,168 @@
+/* eslint-disable no-console */
+import { types as babelTypes, parseAsync, traverse } from '@babel/core';
+import babelSyntaxJsx from '@babel/plugin-syntax-jsx';
+import babelSyntaxTypescript from '@babel/plugin-syntax-typescript';
+import { findMessageNode } from '@mui/internal-babel-plugin-minify-errors';
+import { globby } from 'globby';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { getWorkspacePackages } from '../cli/pnpm.mjs';
+import { BASE_IGNORES, mapConcurrently } from './build.mjs';
+
+/**
+ * @typedef {Object} Args
+ * @property {string} errorCodesPath - The output path to write the extracted error codes.
+ * @property {string[]} [skip=[]] - List of package names to skip. By default, all workspace packages are considered.
+ * @property {import('@mui/internal-babel-plugin-minify-errors').Options['detection']} [detection='opt-in'] - The detection strategy to use when extracting error codes.
+ */
+
+/**
+ * Gets all relevant files for a package to parse.
+ *
+ * @param {import('../cli/pnpm.mjs').PublicPackage} pkg
+ * @returns {Promise<string[]>} An array of file paths.
+ */
+async function getFilesForPackage(pkg) {
+  const srcPath = path.join(pkg.path, 'src');
+  const srcPathExists = await fs
+    .stat(srcPath)
+    .then((stat) => stat.isDirectory())
+    .catch(() => false);
+  // Implementation to extract error codes from all files in the directory
+  const cwd = srcPathExists ? srcPath : pkg.path;
+  const files = await globby('**/*.{js,ts,jsx,tsx,cjs,mjs,cts}', {
+    ignore: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/build/**',
+      'scripts',
+      '**/__{tests,fixtures,mock,mocks}__/**',
+      ...BASE_IGNORES,
+    ],
+    cwd,
+  });
+  return files.map((file) => path.join(cwd, file));
+}
+
+/**
+ * Extracts error codes from all files in a directory.
+ * @param {string[]} files
+ * @param {Set<string>} errors
+ * @param {import('@mui/internal-babel-plugin-minify-errors').Options['detection']} [detection='opt-in']
+ */
+async function extractErrorCodesForWorkspace(files, errors, detection = 'opt-in') {
+  await mapConcurrently(
+    files,
+    async (fullPath) => {
+      const code = await fs.readFile(fullPath, 'utf8');
+      const ast = await parseAsync(code, {
+        filename: fullPath,
+        sourceType: 'module',
+        plugins: [[babelSyntaxTypescript, { isTSX: true }], [babelSyntaxJsx]],
+        configFile: false,
+        babelrc: false,
+        browserslistConfigFile: false,
+        code: false,
+      });
+      if (!ast) {
+        throw new Error(`Failed to parse ${fullPath}`);
+      }
+      traverse(ast, {
+        NewExpression(newExpressionPath) {
+          const { message } =
+            findMessageNode(babelTypes, newExpressionPath, {
+              detection,
+              missingError: 'annotate',
+            }) ?? {};
+          if (message) {
+            errors.add(message.message);
+          }
+        },
+      });
+    },
+    30,
+  );
+}
+
+/**
+ * Extracts error codes from all workspace packages.
+ * @param {Args} args
+ */
+export default async function extractErrorCodes(args) {
+  /**
+   * @type {Set<string>}
+   */
+  const errors = new Set();
+
+  // Find relevant files
+
+  const basePackages = await getWorkspacePackages({
+    publicOnly: true,
+  });
+  const { skip: skipPackages = [], errorCodesPath, detection = 'opt-in' } = args;
+  const packages = basePackages.filter(
+    (pkg) =>
+      // Ignore obvious packages that do not have user-facing errors
+      !pkg.name.startsWith('@mui/internal-') &&
+      !pkg.name.startsWith('@mui-internal/') &&
+      !skipPackages.includes(pkg.name),
+  );
+  const files = await Promise.all(packages.map((pkg) => getFilesForPackage(pkg)));
+  packages.forEach((pkg, index) => {
+    console.log(
+      `🔍 ${pkg.name}: Found ${files[index].length} file${files[index].length > 1 ? 's' : ''}`,
+    );
+  });
+
+  // Extract error codes from said files.
+  const filesToProcess = files.flat();
+  console.log(`🔍 Extracting error codes from ${filesToProcess.length} files...`);
+  await extractErrorCodesForWorkspace(filesToProcess, errors, detection);
+
+  // Write error codes to the specified file.
+  const errorCodeFilePath = path.resolve(errorCodesPath);
+  const fileExists = await fs
+    .stat(errorCodeFilePath)
+    .then((stat) => stat.isFile())
+    .catch((ex) => {
+      if (ex.code === 'ENOENT') {
+        return false;
+      }
+      return new Error(ex.message);
+    });
+
+  if (fileExists instanceof Error) {
+    throw fileExists;
+  }
+  /**
+   * @type {Record<string, string>}
+   */
+  const existingErrorCodes =
+    fileExists === true ? JSON.parse(await fs.readFile(errorCodeFilePath, 'utf-8')) : {};
+  const inverseLookupCode = new Map(
+    Object.entries(existingErrorCodes).map(([key, value]) => [value, Number(key)]),
+  );
+  const originalErrorCount = inverseLookupCode.size;
+  Array.from(errors).forEach((error) => {
+    if (!inverseLookupCode.has(error)) {
+      inverseLookupCode.set(error, inverseLookupCode.size + 1);
+    }
+  });
+  const finalErrorCodes = Array.from(inverseLookupCode.entries()).reduce((acc, [message, code]) => {
+    acc[code] = message;
+    return acc;
+  }, /** @type {Record<string, string>} */ ({}));
+  if (!fileExists) {
+    await fs.mkdir(path.dirname(errorCodeFilePath), { recursive: true });
+  }
+  const newErrorCount = inverseLookupCode.size - originalErrorCount;
+  if (newErrorCount === 0) {
+    console.log(`✅ No new error codes found.`);
+  } else {
+    console.log(
+      `📝 Wrote ${newErrorCount} new error code${newErrorCount > 1 ? 's' : ''} to "${errorCodesPath}"`,
+    );
+    await fs.writeFile(errorCodeFilePath, `${JSON.stringify(finalErrorCodes, null, 2)}\n`);
+  }
+}