@mui/internal-code-infra 0.0.4-canary.7 → 0.0.4-canary.70

package/src/utils/typescript.test.mjs

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 
+import { makeTempDir } from './testUtils.mjs';
 import { copyDeclarations, moveAndTransformDeclarations } from './typescript.mjs';
 
 /**
@@ -18,172 +18,152 @@ async function createFile(filePath, contents = '') {
   await fs.writeFile(filePath, contents, 'utf8');
 }
 
-/**
- * @param {(cwd: string) => Promise<void>} fn
- */
-async function withTempDir(fn) {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'code-infra-typescript-test-'));
-  try {
-    return await fn(tmpDir);
-  } finally {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  }
-}
-
 describe('copyDeclarations', () => {
   it('copies .d.ts files from source to destination', async () => {
-    await withTempDir(async (cwd) => {
-      const sourceDir = path.join(cwd, 'source');
-      const destDir = path.join(cwd, 'dest');
+    const cwd = await makeTempDir();
+    const sourceDir = path.join(cwd, 'source');
+    const destDir = path.join(cwd, 'dest');
 
-      await Promise.all([
-        createFile(path.join(sourceDir, 'index.d.ts'), 'export const foo: string;'),
-        createFile(path.join(sourceDir, 'utils.d.ts'), 'export const bar: number;'),
-        createFile(path.join(sourceDir, 'index.js'), 'export const foo = "test";'),
-      ]);
+    await Promise.all([
+      createFile(path.join(sourceDir, 'index.d.ts'), 'export const foo: string;'),
+      createFile(path.join(sourceDir, 'utils.d.ts'), 'export const bar: number;'),
+      createFile(path.join(sourceDir, 'index.js'), 'export const foo = "test";'),
+    ]);
 
-      await copyDeclarations(sourceDir, destDir);
+    await copyDeclarations(sourceDir, destDir);
 
-      const indexDts = await fs.readFile(path.join(destDir, 'index.d.ts'), 'utf8');
-      const utilsDts = await fs.readFile(path.join(destDir, 'utils.d.ts'), 'utf8');
+    const indexDts = await fs.readFile(path.join(destDir, 'index.d.ts'), 'utf8');
+    const utilsDts = await fs.readFile(path.join(destDir, 'utils.d.ts'), 'utf8');
 
-      expect(indexDts).toBe('export const foo: string;');
-      expect(utilsDts).toBe('export const bar: number;');
+    expect(indexDts).toBe('export const foo: string;');
+    expect(utilsDts).toBe('export const bar: number;');
 
-      const jsExists = await fs.stat(path.join(destDir, 'index.js')).catch(() => null);
-      expect(jsExists).toBeNull();
-    });
+    const jsExists = await fs.stat(path.join(destDir, 'index.js')).catch(() => null);
+    expect(jsExists).toBeNull();
   });
 
   it('copies .d.mts and .d.cts files', async () => {
-    await withTempDir(async (cwd) => {
-      const sourceDir = path.join(cwd, 'source');
-      const destDir = path.join(cwd, 'dest');
+    const cwd = await makeTempDir();
+    const sourceDir = path.join(cwd, 'source');
+    const destDir = path.join(cwd, 'dest');
 
-      await Promise.all([
-        createFile(path.join(sourceDir, 'index.d.mts'), 'export const esm: string;'),
-        createFile(path.join(sourceDir, 'index.d.cts'), 'export const cjs: string;'),
-      ]);
+    await Promise.all([
+      createFile(path.join(sourceDir, 'index.d.mts'), 'export const esm: string;'),
+      createFile(path.join(sourceDir, 'index.d.cts'), 'export const cjs: string;'),
+    ]);
 
-      await copyDeclarations(sourceDir, destDir);
+    await copyDeclarations(sourceDir, destDir);
 
-      const mtsDts = await fs.readFile(path.join(destDir, 'index.d.mts'), 'utf8');
-      const ctsDts = await fs.readFile(path.join(destDir, 'index.d.cts'), 'utf8');
+    const mtsDts = await fs.readFile(path.join(destDir, 'index.d.mts'), 'utf8');
+    const ctsDts = await fs.readFile(path.join(destDir, 'index.d.cts'), 'utf8');
 
-      expect(mtsDts).toBe('export const esm: string;');
-      expect(ctsDts).toBe('export const cjs: string;');
-    });
+    expect(mtsDts).toBe('export const esm: string;');
+    expect(ctsDts).toBe('export const cjs: string;');
   });
 
   it('ignores dotfiles and dot-directories', async () => {
-    await withTempDir(async (cwd) => {
-      const sourceDir = path.join(cwd, 'source');
-      const destDir = path.join(cwd, 'dest');
+    const cwd = await makeTempDir();
+    const sourceDir = path.join(cwd, 'source');
+    const destDir = path.join(cwd, 'dest');
 
-      await Promise.all([
-        createFile(path.join(sourceDir, 'index.d.ts'), 'export const foo: string;'),
-        createFile(path.join(sourceDir, '.hidden.d.ts'), 'export const hidden: string;'),
-        createFile(path.join(sourceDir, '.git', 'config'), 'git config'),
-      ]);
+    await Promise.all([
+      createFile(path.join(sourceDir, 'index.d.ts'), 'export const foo: string;'),
+      createFile(path.join(sourceDir, '.hidden.d.ts'), 'export const hidden: string;'),
+      createFile(path.join(sourceDir, '.git', 'config'), 'git config'),
+    ]);
 
-      await copyDeclarations(sourceDir, destDir);
+    await copyDeclarations(sourceDir, destDir);
 
-      const indexDts = await fs.readFile(path.join(destDir, 'index.d.ts'), 'utf8');
-      expect(indexDts).toBe('export const foo: string;');
+    const indexDts = await fs.readFile(path.join(destDir, 'index.d.ts'), 'utf8');
+    expect(indexDts).toBe('export const foo: string;');
 
-      const hiddenDts = await fs.stat(path.join(destDir, '.hidden.d.ts')).catch(() => null);
-      expect(hiddenDts).toBeNull();
+    const hiddenDts = await fs.stat(path.join(destDir, '.hidden.d.ts')).catch(() => null);
+    expect(hiddenDts).toBeNull();
 
-      const gitDir = await fs.stat(path.join(destDir, '.git')).catch(() => null);
-      expect(gitDir).toBeNull();
-    });
+    const gitDir = await fs.stat(path.join(destDir, '.git')).catch(() => null);
+    expect(gitDir).toBeNull();
   });
 
   it('preserves nested directory structure for .d.ts files', async () => {
-    await withTempDir(async (cwd) => {
-      const sourceDir = path.join(cwd, 'source');
-      const destDir = path.join(cwd, 'dest');
+    const cwd = await makeTempDir();
+    const sourceDir = path.join(cwd, 'source');
+    const destDir = path.join(cwd, 'dest');
 
-      await Promise.all([
-        createFile(path.join(sourceDir, 'types/index.d.ts'), 'export type Foo = string;'),
-        createFile(
-          path.join(sourceDir, 'types/utils/helpers.d.ts'),
-          'export type Helper = () => void;',
-        ),
-      ]);
+    await Promise.all([
+      createFile(path.join(sourceDir, 'types/index.d.ts'), 'export type Foo = string;'),
+      createFile(
+        path.join(sourceDir, 'types/utils/helpers.d.ts'),
+        'export type Helper = () => void;',
+      ),
+    ]);
 
-      await copyDeclarations(sourceDir, destDir);
+    await copyDeclarations(sourceDir, destDir);
 
-      const indexDts = await fs.readFile(path.join(destDir, 'types/index.d.ts'), 'utf8');
-      const helpersDts = await fs.readFile(path.join(destDir, 'types/utils/helpers.d.ts'), 'utf8');
+    const indexDts = await fs.readFile(path.join(destDir, 'types/index.d.ts'), 'utf8');
+    const helpersDts = await fs.readFile(path.join(destDir, 'types/utils/helpers.d.ts'), 'utf8');
 
-      expect(indexDts).toBe('export type Foo = string;');
-      expect(helpersDts).toBe('export type Helper = () => void;');
-    });
+    expect(indexDts).toBe('export type Foo = string;');
+    expect(helpersDts).toBe('export type Helper = () => void;');
   });
 });
 
 describe('moveAndTransformDeclarations', () => {
   it('handles path normalization correctly for Windows-style paths', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      // Create a test .d.ts file
-      await Promise.all([
-        createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
-      ]);
-
-      /** @type {{type: BundleType; dir: string}[]} */
-      const bundles = [{ type: 'esm', dir: 'esm' }];
-
-      // Mock babel transformAsync to avoid actual babel transformations
-      vi.doMock('@babel/core', () => ({
-        transformAsync: vi.fn(async (code) => ({ code })),
-      }));
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: false,
-        packageType: 'module',
-      });
-
-      // Verify file exists in the correct location
-      const dtsFile = path.join(buildDir, 'esm', 'index.d.ts');
-      const stat = await fs.stat(dtsFile).catch(() => null);
-      expect(stat).not.toBeNull();
-      expect(stat?.isFile()).toBe(true);
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    // Create a test .d.ts file
+    await Promise.all([
+      createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
+    ]);
+
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
+
+    // Mock babel transformAsync to avoid actual babel transformations
+    vi.doMock('@babel/core', () => ({
+      transformAsync: vi.fn(async (code) => ({ code })),
+    }));
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Verify file exists in the correct location
+    const dtsFile = path.join(buildDir, 'index.d.ts');
+    const stat = await fs.stat(dtsFile).catch(() => null);
+    expect(stat).not.toBeNull();
+    expect(stat?.isFile()).toBe(true);
   });
 
-  it('preserves original path file when not flat build', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      // Create a test .d.ts file
-      await Promise.all([
-        createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
-      ]);
-
-      /** @type {{type: BundleType; dir: string}[]} */
-      const bundles = [{ type: 'esm', dir: 'esm' }];
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: false,
-        packageType: 'module',
-      });
-
-      // For single bundle non-flat builds, files are copied to bundle dir
-      const dtsFile = path.join(buildDir, 'esm', 'index.d.ts');
-      const stat = await fs.stat(dtsFile).catch(() => null);
-      expect(stat?.isFile()).toBe(true);
+  it('preserves original path file for a single esm bundle', async () => {
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    // Create a test .d.ts file
+    await Promise.all([
+      createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
+    ]);
+
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Files are copied to the build root
+    const dtsFile = path.join(buildDir, 'index.d.ts');
+    const stat = await fs.stat(dtsFile).catch(() => null);
+    expect(stat?.isFile()).toBe(true);
   });
 
   it('correctly compares resolved paths on all platforms', async () => {
@@ -200,94 +180,88 @@ describe('moveAndTransformDeclarations', () => {
   });
 
   it('normalizes paths before reading files', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      const content = 'export const normalized: boolean;';
-      await Promise.all([createFile(path.join(inputDir, 'test.d.ts'), content)]);
-
-      /** @type {{type: BundleType; dir: string}[]} */
-      const bundles = [{ type: 'esm', dir: 'esm' }];
-
-      // Mock babel transformAsync to capture filename
-      const transformMock = vi.fn(async (code) => ({ code }));
-      vi.doMock('@babel/core', () => ({
-        transformAsync: transformMock,
-      }));
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: false,
-        packageType: 'module',
-      });
-
-      // Verify the file was read correctly by checking it exists
-      const dtsFile = path.join(buildDir, 'esm', 'test.d.ts');
-      const stat = await fs.stat(dtsFile).catch(() => null);
-      expect(stat?.isFile()).toBe(true);
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    const content = 'export const normalized: boolean;';
+    await Promise.all([createFile(path.join(inputDir, 'test.d.ts'), content)]);
+
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
+
+    // Mock babel transformAsync to capture filename
+    const transformMock = vi.fn(async (code) => ({ code }));
+    vi.doMock('@babel/core', () => ({
+      transformAsync: transformMock,
+    }));
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Verify the file was read correctly by checking it exists
+    const dtsFile = path.join(buildDir, 'test.d.ts');
+    const stat = await fs.stat(dtsFile).catch(() => null);
+    expect(stat?.isFile()).toBe(true);
   });
 
   it('preserves file when output extension matches in flat builds', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      const content = 'export const flat: string;';
-      await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
-
-      /** @type {{type: BundleType; dir: string}[]} */
-      // ESM + module packageType keeps .d.ts extension in flat builds
-      const bundles = [{ type: 'esm', dir: 'esm' }];
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: true,
-        packageType: 'module',
-      });
-
-      // Since extension doesn't change (.d.ts -> .d.ts), file should remain
-      const outputFile = path.join(buildDir, 'esm', 'index.d.ts');
-      const outputStat = await fs.stat(outputFile).catch(() => null);
-      expect(outputStat?.isFile()).toBe(true);
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    const content = 'export const flat: string;';
+    await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
+
+    /** @type {BundleType[]} */
+    // ESM + module packageType keeps .d.ts extension in flat builds
+    const bundles = ['esm'];
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Since extension doesn't change (.d.ts -> .d.ts), file should remain
+    const outputFile = path.join(buildDir, 'index.d.ts');
+    const outputStat = await fs.stat(outputFile).catch(() => null);
+    expect(outputStat?.isFile()).toBe(true);
   });
 
   it('removes original when output extension differs in flat builds', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      const content = 'export const transformed: string;';
-      await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
-      /** @type {{type: BundleType; dir: string}[]} */
-
-      // CJS bundle with module packageType creates .d.cts
-      const bundles = [{ type: 'cjs', dir: 'cjs' }];
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: true,
-        packageType: 'module',
-      });
-
-      // Transformed file with new extension should exist
-      const outputFile = path.join(buildDir, 'cjs', 'index.d.cts');
-      const outputStat = await fs.stat(outputFile).catch(() => null);
-      expect(outputStat?.isFile()).toBe(true);
-
-      // Original .d.ts should be removed
-      const originalFile = path.join(buildDir, 'cjs', 'index.d.ts');
-      const originalStat = await fs.stat(originalFile).catch(() => null);
-      expect(originalStat).toBeNull();
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    const content = 'export const transformed: string;';
+    await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
+    /** @type {BundleType[]} */
+
+    // CJS bundle with module packageType creates .d.cts
+    const bundles = ['cjs'];
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Transformed file with new extension should exist
+    const outputFile = path.join(buildDir, 'index.d.cts');
+    const outputStat = await fs.stat(outputFile).catch(() => null);
+    expect(outputStat?.isFile()).toBe(true);
+
+    // Original .d.ts should be removed
+    const originalFile = path.join(buildDir, 'index.d.ts');
+    const originalStat = await fs.stat(originalFile).catch(() => null);
+    expect(originalStat).toBeNull();
   });
 
   it('handles mixed separator paths in comparisons on Windows', async () => {
@@ -306,75 +280,62 @@ describe('moveAndTransformDeclarations', () => {
   });
 
   it('uses normalized paths for writesToOriginalPath check', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      const content = 'export const component: string;';
-      await Promise.all([createFile(path.join(inputDir, 'component.d.ts'), content)]);
-      /** @type {{type: BundleType; dir: string}[]} */
-
-      // ESM + commonjs packageType creates .d.mts
-      const bundles = [{ type: 'esm', dir: 'esm' }];
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: true,
-        packageType: 'commonjs',
-      });
-
-      // The .d.mts file should exist
-      const transformedFile = path.join(buildDir, 'esm', 'component.d.mts');
-      const transformedStat = await fs.stat(transformedFile).catch(() => null);
-      expect(transformedStat?.isFile()).toBe(true);
-
-      // Original .d.ts should be removed because extension changed
-      const originalFile = path.join(buildDir, 'esm', 'component.d.ts');
-      const originalStat = await fs.stat(originalFile).catch(() => null);
-      expect(originalStat).toBeNull();
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    const content = 'export const component: string;';
+    await Promise.all([createFile(path.join(inputDir, 'component.d.ts'), content)]);
+    /** @type {BundleType[]} */
+
+    // ESM + commonjs packageType creates .d.mts
+    const bundles = ['esm'];
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'commonjs',
     });
+
+    // The .d.mts file should exist
+    const transformedFile = path.join(buildDir, 'component.d.mts');
+    const transformedStat = await fs.stat(transformedFile).catch(() => null);
+    expect(transformedStat?.isFile()).toBe(true);
+
+    // Original .d.ts should be removed because extension changed
+    const originalFile = path.join(buildDir, 'component.d.ts');
+    const originalStat = await fs.stat(originalFile).catch(() => null);
+    expect(originalStat).toBeNull();
   });
 
   it('handles path normalization with multiple bundles in flat mode', async () => {
-    await withTempDir(async (cwd) => {
-      const inputDir = path.join(cwd, 'input');
-      const buildDir = path.join(cwd, 'build');
-
-      const content = 'export const multi: string;';
-      await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
-
-      // Multiple bundles: files are copied to buildDir, not directly to bundle dirs
-      /** @type {{type: BundleType; dir: string}[]} */
-      const bundles = [
-        { type: 'esm', dir: 'esm' },
-        { type: 'cjs', dir: 'cjs' },
-      ];
-
-      await moveAndTransformDeclarations({
-        inputDir,
-        buildDir,
-        bundles,
-        isFlat: true,
-        packageType: 'module',
-      });
-
-      // Each bundle gets its own transformed copy
-      // ESM with module packageType keeps .d.ts
-      const esmFile = path.join(buildDir, 'esm', 'index.d.ts');
-      const esmStat = await fs.stat(esmFile).catch(() => null);
-      expect(esmStat?.isFile()).toBe(true);
-
-      // CJS with module packageType gets .d.cts
-      const cjsFile = path.join(buildDir, 'cjs', 'index.d.cts');
-      const cjsStat = await fs.stat(cjsFile).catch(() => null);
-      expect(cjsStat?.isFile()).toBe(true);
-
-      // Original in buildDir should be removed in flat mode since writesToOriginalPath is false
-      const originalFile = path.join(buildDir, 'index.d.ts');
-      const originalStat = await fs.stat(originalFile).catch(() => null);
-      expect(originalStat).toBeNull();
+    const cwd = await makeTempDir();
+    const inputDir = path.join(cwd, 'input');
+    const buildDir = path.join(cwd, 'build');
+
+    const content = 'export const multi: string;';
+    await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
+
+    /** @type {BundleType[]} */
+    const bundles = ['esm', 'cjs'];
+
+    await moveAndTransformDeclarations({
+      inputDir,
+      buildDir,
+      bundles,
+      packageType: 'module',
     });
+
+    // Each bundle writes its own transformed copy to the build root.
+    // ESM with module packageType keeps .d.ts (and is the original, so it stays)
+    const esmFile = path.join(buildDir, 'index.d.ts');
+    const esmStat = await fs.stat(esmFile).catch(() => null);
+    expect(esmStat?.isFile()).toBe(true);
+
+    // CJS with module packageType gets .d.cts
+    const cjsFile = path.join(buildDir, 'index.d.cts');
+    const cjsStat = await fs.stat(cjsFile).catch(() => null);
+    expect(cjsStat?.isFile()).toBe(true);
   });
 });

package/vale/.vale.ini

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

package/vale/styles/MUI/CorrectReferenceAllCases.yml

@@ -0,0 +1,43 @@
+# 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
+  JSDOM: jsdom

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