@mui/internal-code-infra 0.0.4-canary.8 → 0.0.4-canary.81

package/src/utils/git.mjs

@@ -24,6 +24,10 @@ export async function getRepositoryInfo(cwd = process.cwd()) {
    * @type {Set<string>}
    */
   const repoRemotes = new Set();
+  /**
+   * @type {Map<string, { owner: string, repo: string }>}
+   */
+  const validRemotes = new Map();
 
   for (const line of lines) {
     // Match pattern: "remoteName url (fetch|push)"
@@ -36,20 +40,25 @@ export async function getRepositoryInfo(cwd = process.cwd()) {
           cause[remoteName] = `Remote is not a GitHub repository under 'mui' organization: ${url}`;
           continue;
         }
-        return {
-          owner: parsed.owner,
-          repo: parsed.name,
-          remoteName,
-        };
+        if (!validRemotes.has(remoteName)) {
+          validRemotes.set(remoteName, { owner: parsed.owner, repo: parsed.name });
+        }
       } catch (error) {
         cause[remoteName] = `Failed to parse URL for remote ${remoteName}: ${url}`;
       }
-    }
-    if (type !== '(push)') {
+    } else if (type !== '(push)') {
       throw new Error(`Unexpected line format for "git remote -v": "${line}"`);
     }
   }
 
+  const preferredOrder = ['upstream', 'origin', ...validRemotes.keys()];
+  for (const name of preferredOrder) {
+    const match = validRemotes.get(name);
+    if (match) {
+      return { ...match, remoteName: name };
+    }
+  }
+
   throw new Error(
     `Failed to find correct remote(s) in : ${Array.from(repoRemotes.keys()).join(', ')}`,
     { cause },
@@ -64,3 +73,14 @@ export async function getCurrentGitSha() {
   const result = await $`git rev-parse HEAD`;
   return result.stdout.trim();
 }
+
+/**
+ * Check whether a tag already exists on the origin remote
+ * @param {string} tagName - Tag name to check (e.g. `v1.2.3`)
+ * @param {string} [cwd=process.cwd()]
+ * @returns {Promise<boolean>} True if the tag exists on origin
+ */
+export async function remoteGitTagExists(tagName, cwd = process.cwd()) {
+  const { stdout } = await $({ cwd })`git ls-remote --tags origin refs/tags/${tagName}`;
+  return stdout.trim().length > 0;
+}

package/src/utils/pnpm.mjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as semver from 'semver';
+import { parseDocument, isMap } from 'yaml';
 
 /**
  * @typedef {Object} PrivatePackage
@@ -48,6 +50,7 @@ import * as semver from 'semver';
  * @property {boolean} [publicOnly=false] - Whether to filter to only public packages
  * @property {boolean} [nonPublishedOnly=false] - Whether to filter to only non-published packages. It by default means public packages yet to be published.
  * @property {string} [cwd] - Current working directory to run pnpm command in
+ * @property {string[]} [filter] - Same as filtering packages with --filter in pnpm. Only include packages matching the filter. See https://pnpm.io/filtering.
  */
 
 /**
@@ -73,15 +76,35 @@ import * as semver from 'semver';
  * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
  */
 export async function getWorkspacePackages(options = {}) {
-  const { sinceRef = null, publicOnly = false, nonPublishedOnly = false } = options;
+  const { sinceRef = null, publicOnly = false, nonPublishedOnly = false, filter = [] } = options;
 
-  // Build command with conditional filter
-  const filterArg = sinceRef ? ['--filter', `...[${sinceRef}]`] : [];
-  const result = options.cwd
-    ? await $({ cwd: options.cwd })`pnpm ls -r --json --depth -1 ${filterArg}`
-    : await $`pnpm ls -r --json --depth -1 ${filterArg}`;
-  /** @type {PnpmListResultItem[]} */
-  const packageData = JSON.parse(result.stdout);
+  /**
+   * Run `pnpm ls` with the given --filter args and return the parsed list.
+   * @param {string[]} filterArg
+   * @returns {Promise<PnpmListResultItem[]>}
+   */
+  const listPackages = async (filterArg) => {
+    const result = await $({ cwd: options.cwd })`pnpm ls -r --json --depth -1 ${filterArg}`;
+    return JSON.parse(result.stdout);
+  };
+
+  // pnpm ORs --filter args, so intersect "matches filter" with "changed since ref"
+  // in JS. The `[ref]` selector (no `...`) excludes dependents of changed packages.
+  const patternFilterArg = filter.flatMap((f) => ['--filter', f]);
+  const [candidatePackages, changedPackages] = await Promise.all([
+    listPackages(patternFilterArg),
+    // null when no sinceRef (skip the constraint); [] when nothing changed.
+    sinceRef ? listPackages(['--filter', `[${sinceRef}]`]) : Promise.resolve(null),
+  ]);
+  let packageData = candidatePackages;
+  if (changedPackages) {
+    // sinceRef given but nothing changed → no packages, regardless of filter.
+    if (changedPackages.length === 0) {
+      return [];
+    }
+    const changedPaths = new Set(changedPackages.map((pkg) => pkg.path));
+    packageData = packageData.filter((pkg) => changedPaths.has(pkg.path));
+  }
 
   // Filter packages based on options
   const filteredPackages = packageData.flatMap((pkg) => {
@@ -148,11 +171,17 @@ export async function getPackageVersionInfo(packageName, baseVersion) {
   }
 }
 
+/**
+ * @typedef {Object} PublishSummaryEntry
+ * @property {string} name
+ * @property {string} version
+ */
+
 /**
  * Publish packages with the given options
  * @param {PublicPackage[]} packages - Packages to publish
  * @param {PublishOptions} [options={}] - Publishing options
- * @returns {Promise<void>}
+ * @returns {Promise<PublishSummaryEntry[]>}
  */
 export async function publishPackages(packages, options = {}) {
   const args = [];
@@ -172,7 +201,183 @@ export async function publishPackages(packages, options = {}) {
     args.push('--no-git-checks');
   }
 
-  await $({ stdio: 'inherit' })`pnpm -r publish --access public --tag=${tag} ${args}`;
+  const workspaceDir = await findWorkspaceDir(process.cwd());
+  if (!workspaceDir) {
+    throw new Error('Could not find pnpm workspace root');
+  }
+  const summaryPath = path.join(workspaceDir, 'pnpm-publish-summary.json');
+
+  // Clean up any leftover summary file from a previous run
+  await fs.rm(summaryPath, { force: true });
+
+  await $({
+    stdio: 'inherit',
+    env: { npm_config_loglevel: 'warn' },
+  })`pnpm -r publish --access public --tag=${tag} --report-summary ${args}`;
+
+  const summary = JSON.parse(await fs.readFile(summaryPath, 'utf-8'));
+  await fs.rm(summaryPath, { force: true });
+  return /** @type {PublishSummaryEntry[]} */ (summary.publishedPackages);
+}
+
+/**
+ * @typedef {Object} GetTransitiveDependenciesOptions
+ * @property {Map<string, string>} [workspacePathByName] - Map of workspace package name to directory path
+ * @property {boolean} [includeDev=true] - Whether to include devDependencies in the traversal
+ */
+
+/**
+ * Get all transitive workspace dependencies for a set of packages.
+ *
+ * Only follows deps whose version spec starts with `workspace:` (e.g. `workspace:*`
+ * or `workspace:^`), meaning they are sourced directly from the monorepo. Pinned
+ * external versions (e.g. `^1.0.0`) are ignored even when the package name exists
+ * in the workspace. Traverses `dependencies` and optionally `devDependencies`.
+ * Results are cached per package so each package is read from disk at most once
+ * regardless of how many roots depend on it.
+ *
+ * @param {string[]} packageNames - Package names to start the traversal from
+ * @param {GetTransitiveDependenciesOptions} [options]
+ * @returns {Promise<Set<string>>} All reachable workspace package names, including the input packages themselves
+ */
+export async function getTransitiveDependencies(packageNames, options = {}) {
+  const { includeDev = true, workspacePathByName = new Map() } = options;
+
+  /** @type {Map<string, Promise<Set<string>>>} */
+  const cache = new Map();
+
+  /**
+   * @param {string} packageName
+   * @returns {Promise<Set<string>>}
+   */
+  function collectDeps(packageName) {
+    const cached = cache.get(packageName);
+    if (cached) {
+      return cached;
+    }
+
+    const promise = (async () => {
+      const packagePath = workspacePathByName.get(packageName);
+      if (!packagePath) {
+        throw new Error(`Workspace "${packageName}" not found`);
+      }
+
+      const pkgJson = await readPackageJson(packagePath);
+      const allDepEntries = [
+        ...Object.entries(pkgJson.dependencies ?? {}),
+        ...(includeDev ? Object.entries(pkgJson.devDependencies ?? {}) : []),
+      ];
+      const workspaceDeps = allDepEntries
+        .filter(
+          ([dep, spec]) =>
+            workspacePathByName.has(dep) &&
+            typeof spec === 'string' &&
+            spec.startsWith('workspace:'),
+        )
+        .map(([dep]) => dep);
+
+      const recursiveResults = await Promise.all(workspaceDeps.map(collectDeps));
+      return new Set([...workspaceDeps, ...recursiveResults.flatMap((s) => [...s])]);
+    })();
+
+    cache.set(packageName, promise);
+    return promise;
+  }
+
+  for (const name of packageNames) {
+    if (!workspacePathByName.has(name)) {
+      throw new Error(`Workspace "${name}" not found`);
+    }
+  }
+
+  const results = await Promise.all(packageNames.map(collectDeps));
+  return new Set([...packageNames, ...results.flatMap((s) => [...s])]);
+}
+
+/**
+ * Pure validation logic: given a publish set and workspace maps, checks that all
+ * transitive hard workspace dependencies are covered and none are private.
+ *
+ * A hard dependency is one listed in `dependencies` (not `peerDependencies` or
+ * `devDependencies`) using a `workspace:` version specifier (e.g. `workspace:*` or
+ * `workspace:^`). Peer dependencies are never bundled and dev dependencies are not installed
+ * on consumer devices - both are excluded regardless of version specifier. Pinned-version
+ * references in `dependencies` are also excluded - they resolve from the registry and do
+ * not need to be co-published.
+ *
+ * @param {PublicPackage[]} packages - The packages intended for publishing
+ * @param {Map<string, PublicPackage | PrivatePackage>} workspacePackageByName - All workspace packages by name
+ * @param {Map<string, string>} workspacePathByName - Map of workspace package name to directory path
+ * @returns {Promise<{issues: string[]}>}
+ *   List of human-readable issue strings. Empty when the dependency set is valid.
+ * @internal
+ */
+export async function checkPublishDependencies(
+  packages,
+  workspacePackageByName,
+  workspacePathByName,
+) {
+  const publishedNames = new Set(packages.map((pkg) => pkg.name));
+
+  const transitiveDeps = await getTransitiveDependencies(
+    packages.map((pkg) => pkg.name),
+    { includeDev: false, workspacePathByName },
+  );
+
+  /** @type {Set<string>} */
+  const privateButRequired = new Set();
+  /** @type {Set<string>} */
+  const missingFromPublish = new Set();
+
+  for (const depName of transitiveDeps) {
+    if (publishedNames.has(depName)) {
+      continue;
+    }
+    const workspacePkg = workspacePackageByName.get(depName);
+    if (workspacePkg?.isPrivate) {
+      privateButRequired.add(depName);
+    } else {
+      missingFromPublish.add(depName);
+    }
+  }
+
+  /** @type {string[]} */
+  const issues = [];
+
+  if (privateButRequired.size > 0) {
+    issues.push(
+      `The following private workspace packages are required as dependencies but cannot be published: ${[...privateButRequired].join(', ')}`,
+    );
+  }
+
+  if (missingFromPublish.size > 0) {
+    issues.push(
+      `The following workspace packages are required as dependencies but are not included in the publish set: ${[...missingFromPublish].join(', ')}. Add them to the --filter list.`,
+    );
+  }
+
+  return { issues };
+}
+
+/**
+ * Validate that a set of packages covers all of their transitive hard workspace dependencies,
+ * and that none of those dependencies are private (which would make them unpublishable).
+ *
+ * @param {PublicPackage[]} packages - The packages intended for publishing
+ * @returns {Promise<{issues: string[]}>}
+ *   List of human-readable issue strings. Empty when the dependency set is valid.
+ */
+export async function validatePublishDependencies(packages) {
+  const allWorkspacePackages = await getWorkspacePackages();
+
+  const workspacePackageByName = /** @type {Map<string, PublicPackage | PrivatePackage>} */ (
+    new Map(allWorkspacePackages.flatMap((pkg) => (pkg.name ? [[pkg.name, pkg]] : [])))
+  );
+  const workspacePathByName = new Map(
+    allWorkspacePackages.flatMap((pkg) => (pkg.name ? [[pkg.name, pkg.path]] : [])),
+  );
+
+  return checkPublishDependencies(packages, workspacePackageByName, workspacePathByName);
 }
 
 /**
@@ -196,6 +401,68 @@ export async function writePackageJson(packagePath, packageJson) {
   await fs.writeFile(path.join(packagePath, 'package.json'), content);
 }
 
+/**
+ * Write the computed overrides into whichever manifest already defines
+ * overrides — preferring pnpm-workspace.yaml, falling back to package.json
+ * `pnpm.overrides`, defaulting to pnpm-workspace.yaml — and persist the result.
+ * A missing pnpm-workspace.yaml is treated as empty, so a fresh file is created
+ * with just the `overrides:` block. Rejects a `resolutions` field in
+ * package.json because pnpm 11 silently ignores it.
+ *
+ * @param {string} workspaceDir - Workspace root directory
+ * @param {Record<string, string>} overrides - Overrides to apply
+ * @returns {Promise<void>}
+ */
+export async function writeOverridesToWorkspace(workspaceDir, overrides) {
+  const workspaceYamlPath = path.join(workspaceDir, 'pnpm-workspace.yaml');
+  const yamlPromise = fs.readFile(workspaceYamlPath, { encoding: 'utf8' }).catch((error) => {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code !== 'ENOENT') {
+      throw error;
+    }
+    return '';
+  });
+  const [rootPackageJson, yamlSource] = await Promise.all([
+    readPackageJson(workspaceDir),
+    yamlPromise,
+  ]);
+
+  const { resolutions } = rootPackageJson;
+  if (resolutions && Object.keys(resolutions).length > 0) {
+    throw new Error(
+      'Found a "resolutions" field in package.json. pnpm 11 ignores it silently. ' +
+        'Move those entries into the "overrides:" key of pnpm-workspace.yaml.',
+    );
+  }
+
+  // Parsed once, reused for both the read (does it have overrides?) and the write.
+  const doc = parseDocument(yamlSource);
+  const existing = doc.get('overrides');
+  const workspaceHasOverrides = isMap(existing) && existing.items.length > 0;
+
+  const pnpm = /** @type {{ overrides?: Record<string, string> } | undefined} */ (
+    rootPackageJson.pnpm
+  );
+  const packageJsonOverrides = pnpm?.overrides;
+
+  // Write where overrides already live; default to the workspace file.
+  if (
+    !workspaceHasOverrides &&
+    packageJsonOverrides &&
+    Object.keys(packageJsonOverrides).length > 0
+  ) {
+    await writePackageJson(workspaceDir, {
+      ...rootPackageJson,
+      pnpm: { ...pnpm, overrides: { ...packageJsonOverrides, ...overrides } },
+    });
+    return;
+  }
+
+  for (const [name, version] of Object.entries(overrides)) {
+    doc.setIn(['overrides', name], version);
+  }
+  await fs.writeFile(workspaceYamlPath, doc.toString());
+}
+
 /**
  * Resolve a package@version specifier to an exact version
  * @param {string} packageSpec - Package specifier in format "package@version"

package/src/utils/testUtils.mjs

@@ -0,0 +1,18 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { onTestFinished } from 'vitest';
+
+/**
+ * Creates a temporary directory and registers an `onTestFinished` hook to
+ * remove it automatically when the current test ends — even if the test throws.
+ *
+ * @returns {Promise<string>} The path of the created temporary directory.
+ */
+export async function makeTempDir() {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'code-infra-test-'));
+  onTestFinished(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+  return tmpDir;
+}

package/src/utils/typescript.mjs

@@ -111,30 +111,21 @@ export async function copyDeclarations(sourceDirectory, destinationDirectory, op
  * @param {Object} param0
  * @param {string} param0.inputDir
  * @param {string} param0.buildDir
- * @param {{type: import('../utils/build.mjs').BundleType, dir: string}[]} param0.bundles
- * @param {boolean} [param0.isFlat]
+ * @param {import('../utils/build.mjs').BundleType[]} param0.bundles
  * @param {'module' | 'commonjs'} [param0.packageType]
  * @returns
  */
-export async function moveAndTransformDeclarations({
-  inputDir,
-  buildDir,
-  bundles,
-  isFlat,
-  packageType,
-}) {
-  // Directly copy to the bundle directory if there's only one bundle, mainly for esm, since
-  // the js files are inside 'esm' folder. resolve-imports plugin needs d.ts to be alongside js files to
-  // resolve paths correctly.
-  const toCopyDir = bundles.length === 1 ? path.join(buildDir, bundles[0].dir) : buildDir;
-  await fs.cp(inputDir, toCopyDir, {
+export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles, packageType }) {
+  // d.ts files sit alongside the js files in the build root so the resolve-imports
+  // plugin can resolve paths correctly.
+  await fs.cp(inputDir, buildDir, {
     recursive: true,
     force: false,
   });
 
-  const dtsFiles = await globby('**/*.d.ts', { absolute: true, cwd: toCopyDir });
+  const dtsFiles = await globby('**/*.d.ts', { absolute: true, cwd: buildDir });
   if (dtsFiles.length === 0) {
-    console.log(`No d.ts files found in ${toCopyDir}. Skipping transformation.`);
+    console.log(`No d.ts files found in ${buildDir}. Skipping transformation.`);
     return;
   }
 
@@ -144,37 +135,30 @@ export async function moveAndTransformDeclarations({
       // Normalize to native separators to make path comparisons reliable on Windows
       const nativeDtsFile = path.normalize(dtsFile);
       const content = await fs.readFile(nativeDtsFile, 'utf8');
-      const relativePath = path.relative(toCopyDir, nativeDtsFile);
+      const relativePath = path.relative(buildDir, nativeDtsFile);
 
-      const writesToOriginalPath =
-        isFlat &&
-        bundles.some((bundle) => {
-          const newFileExtension = getOutExtension(bundle.type, {
-            isFlat,
-            isType: true,
-            packageType,
-          });
-          const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
-          const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
-          // Ensure both paths are normalized before comparison (fixes Windows posix vs win32 separators)
-          return path.resolve(outFilePath) === path.resolve(nativeDtsFile);
+      const writesToOriginalPath = bundles.some((bundle) => {
+        const newFileExtension = getOutExtension(bundle, {
+          isType: true,
+          packageType,
         });
+        const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
+        const outFilePath = path.join(buildDir, outFileRelative);
+        // Ensure both paths are normalized before comparison (fixes Windows posix vs win32 separators)
+        return path.resolve(outFilePath) === path.resolve(nativeDtsFile);
+      });
 
       await Promise.all(
         bundles.map(async (bundle) => {
-          const importExtension = getOutExtension(bundle.type, {
-            isFlat,
+          const importExtension = getOutExtension(bundle, {
             packageType,
           });
-          const newFileExtension = getOutExtension(bundle.type, {
-            isFlat,
+          const newFileExtension = getOutExtension(bundle, {
             isType: true,
             packageType,
           });
-          const outFileRelative = isFlat
-            ? relativePath.replace(/\.d\.ts$/, newFileExtension)
-            : relativePath;
-          const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
+          const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
+          const outFilePath = path.join(buildDir, outFileRelative);
 
           const babelPlugins = [
             [pluginTypescriptSyntax, { dts: true }],
@@ -194,7 +178,7 @@ export async function moveAndTransformDeclarations({
           }
         }),
       );
-      if (isFlat && !writesToOriginalPath) {
+      if (!writesToOriginalPath) {
         await fs.unlink(nativeDtsFile);
       }
     },
@@ -208,9 +192,8 @@ export async function moveAndTransformDeclarations({
  * After copying, babel transformations are applied to the copied files because they need to be alongside the actual js files for proper resolution.
  *
  * @param {Object} param0
- * @param {boolean} [param0.isFlat = false] - Whether to place generated declaration files in a flattened directory.
  * @param {boolean} [param0.verbose = false] - Whether to log additional information while generating and moving declaration files.
- * @param {{type: import('../utils/build.mjs').BundleType, dir: string}[]} param0.bundles - The bundles to create declarations for.
+ * @param {import('../utils/build.mjs').BundleType[]} param0.bundles - The bundles to create declarations for.
  * @param {string} param0.srcDir - The source directory.
  * @param {string} param0.buildDir - The build directory.
  * @param {string} param0.cwd - The current working directory.
@@ -225,7 +208,6 @@ export async function createTypes({
   cwd,
   skipTsc,
   useTsgo = false,
-  isFlat = false,
   packageType,
   verbose,
 }) {
@@ -253,7 +235,6 @@ export async function createTypes({
       inputDir: tmpDir,
       buildDir,
       bundles,
-      isFlat,
       packageType,
     });
   } finally {

package/vale/.vale.ini

@@ -0,0 +1 @@
+StylesPath = styles

package/vale/styles/MUI/CorrectReferenceAllCases.yml

@@ -0,0 +1,42 @@
+# Enforce a single way to write specific terms or phrases.
+extends: substitution
+message: Use '%s' instead of '%s'
+level: error
+ignorecase: true # There is only one correct way to spell those, so we want to match inputs regardless of case.
+# swap maps tokens in form of bad: good
+# for more information: https://vale.sh/docs/topics/styles/#substitution
+swap:
+  ' api': ' API'
+  'typescript ': 'TypeScript '
+  ' ts': ' TypeScript'
+  javascript: JavaScript
+  ' js': ' JavaScript'
+  ' css ': ' CSS '
+  ' html ': ' HTML '
+  NPM: npm # https://css-tricks.com/start-sentence-npm/
+  Github: GitHub
+  StackOverflow: Stack Overflow
+  Stack Overflow: Stack Overflow
+  CSS modules: CSS Modules
+  Tailwind CSS: Tailwind CSS
+  Heat map: Heatmap
+  Tree map: Treemap
+  Sparkline Chart: Sparkline chart
+  Gauge Chart: Gauge chart
+  Treemap Chart: Treemap chart
+  sub-component: subcomponent
+  sub-components: subcomponents
+  use-case: use case
+  usecase: use case
+  Material 3: Material Design 3
+  VSCode: VS Code
+  VS Code: VS Code
+  'Codesandbox ': 'CodeSandbox '
+  code sandbox: CodeSandbox
+  Stackblitz: StackBlitz
+  Webpack: webpack # https://x.com/wSokra/status/855800490713649152
+  app router: App Router # Next.js
+  pages router: Pages Router # Next.js
+  page router: Pages Router # Next.js
+  eslint: ESLint
+  ES modules: ES modules

package/vale/styles/MUI/CorrectRererenceCased.yml

@@ -0,0 +1,14 @@
+# Write things correctly, please no wrong references.
+extends: substitution
+message: Use '%s' instead of '%s'
+level: error
+ignorecase: false
+# swap maps tokens in form of bad: good
+# for more information: https://vale.sh/docs/topics/styles/#substitution
+swap:
+  eg: e.g.
+  eg\.: e.g.
+  e\.g: e.g.
+  ie: i.e.
+  ie\.: i.e.
+  i\.e: i.e.

package/vale/styles/MUI/GoogleLatin.yml

@@ -0,0 +1,11 @@
+extends: substitution
+message: Use '%s' instead of '%s'
+link: https://developers.google.com/style/abbreviations
+ignorecase: false
+level: error
+nonword: true
+action:
+  name: replace
+swap:
+  '\b(?:eg|e\.g\.)(?=[\s,;])': for example
+  '\b(?:ie|i\.e\.)(?=[\s,;])': that is

package/vale/styles/MUI/MuiBrandName.yml

@@ -0,0 +1,22 @@
+# Without a non-breaking space, brand names can be split in the middle
+# with the start and end on two different lines.
+# For example, Apple does this meticulously with their brand name: https://www.apple.com/macbook-air/.
+# Also read https://www.chrisdpeters.com/blog/using-non-breaking-spaces-to-help-with-branding/ for why.
+extends: substitution
+message: Use a non-breaking space (option+space on Mac, Alt+0160 on Windows or AltGr+Space on Linux, instead of space) for brand name ('%s' instead of '%s')
+level: error
+ignorecase: true
+# swap maps tokens in form of bad: good
+# for more information: https://vale.sh/docs/topics/styles/#substitution
+swap:
+  Material UI: Material UI
+  MUI X: MUI X
+  Base UI: Base UI
+  MUI Base: MUI Base
+  MUI System: MUI System
+  MUI Store: MUI Store
+  MUI Core: MUI Core
+  MUI Toolpad: Toolpad
+  MUI Toolpad: Toolpad
+  MUI Connect: MUI Connect
+  Pigment CSS: Pigment CSS