@mui/internal-code-infra 0.0.3-canary.87 → 0.0.3-canary.89

package/build/eslint/mui/rules/flatten-parentheses.d.mts

@@ -0,0 +1,5 @@
+declare const _default: ESLintUtils.RuleModule<"flattenParentheses", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;
+import { ESLintUtils } from '@typescript-eslint/utils';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.3-canary.87",
+  "version": "0.0.3-canary.89",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "type": "module",
   "license": "MIT",
@@ -152,7 +152,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "4ade0c29b3effbc7af0278f249019ce294fed0d4",
+  "gitSha": "67eca269ee332f573b258735ece9f448874e2468",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "typescript": "tsc -p tsconfig.json",

package/src/cli/cmdPublishNewPackage.mjs

@@ -7,6 +7,9 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
+
+import { getRepositoryInfo } from '../utils/git.mjs';
 import { getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
@@ -31,6 +34,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       console.log('No new packages to publish.');
       return;
     }
+    const cwd = process.cwd();
 
     console.log(`Found ${newPackages.map((pkg) => pkg.name).join(', ')} to publish.`);
 
@@ -42,14 +46,24 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       return;
     }
 
+    const workspaceDir = await findWorkspaceDir(cwd);
+    if (!workspaceDir) {
+      throw new Error('This command should be run in a workspace.');
+    }
     await Promise.all(
       newPackages.map(async (pkg) => {
         const newPkgDir = await fs.mkdtemp(path.join(os.tmpdir(), 'publish-new-package-'));
         try {
           await fs.mkdir(newPkgDir, { recursive: true });
+          const repo = await getRepositoryInfo();
           const packageJson = {
             name: pkg.name,
             version: '0.0.1',
+            repository: {
+              type: 'git',
+              url: `git+https://github.com/${repo.owner}/${repo.remoteName}.git`,
+              directory: path.relative(workspaceDir, pkg.path).split(path.sep).join('/'),
+            },
           };
           await fs.writeFile(
             path.join(newPkgDir, 'package.json'),

package/src/eslint/mui/config.mjs

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

package/src/eslint/mui/index.mjs

@@ -10,6 +10,7 @@ import requireDevWrapper from './rules/require-dev-wrapper.mjs';
 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';
 
 export default /** @type {import('eslint').ESLint.Plugin} */ ({
   meta: {
@@ -30,5 +31,6 @@ export default /** @type {import('eslint').ESLint.Plugin} */ ({
     'require-dev-wrapper': requireDevWrapper,
     // Some discrepancies between TypeScript and ESLint types - casting to unknown
     'add-undef-to-optional': /** @type {unknown} */ (addUndefToOptional),
+    'flatten-parentheses': /** @type {unknown} */ (flattenParentheses),
   },
 });

package/src/eslint/mui/rules/flatten-parentheses.mjs

@@ -0,0 +1,84 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) =>
+    `https://github.com/mui/mui-public/blob/master/packages/code-infra/src/eslint/mui/rules/${name}.mjs`,
+);
+
+/**
+ * Returns the source range including surrounding parentheses, or null if the node is not parenthesized.
+ * @param {import('@typescript-eslint/types').TSESTree.Node} node
+ * @param {import('@typescript-eslint/utils').TSESLint.SourceCode} sourceCode
+ * @returns {[number, number] | null}
+ */
+function getParenthesizedRange(node, sourceCode) {
+  const tokenBefore = sourceCode.getTokenBefore(node);
+  const tokenAfter = sourceCode.getTokenAfter(node);
+
+  if (
+    tokenBefore?.value === '(' &&
+    tokenBefore?.type === 'Punctuator' &&
+    tokenAfter?.value === ')' &&
+    tokenAfter?.type === 'Punctuator'
+  ) {
+    return [tokenBefore.range[0], tokenAfter.range[1]];
+  }
+
+  return null;
+}
+
+export default createRule({
+  meta: {
+    docs: {
+      description:
+        'Flatten unnecessary parentheses in TypeScript unions and intersections when safe to do so. NOTE: This rule will become obsolete once Prettier handles this formatting automatically (see https://github.com/prettier/prettier/issues/13500).',
+    },
+    messages: {
+      flattenParentheses:
+        'Unnecessary parentheses in {{ operatorType }}. The inner types can be flattened.',
+    },
+    type: 'suggestion',
+    fixable: 'code',
+    schema: [],
+  },
+  name: 'flatten-parentheses',
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    /**
+     * @param {import('@typescript-eslint/types').TSESTree.TSUnionType | import('@typescript-eslint/types').TSESTree.TSIntersectionType} node
+     */
+    function checkNode(node) {
+      const operatorType = node.type === AST_NODE_TYPES.TSUnionType ? 'union' : 'intersection';
+
+      for (const typeNode of node.types) {
+        // Only flatten when the child operator matches the parent (union-in-union or intersection-in-intersection)
+        if (typeNode.type !== node.type) {
+          continue;
+        }
+
+        const range = getParenthesizedRange(typeNode, sourceCode);
+        if (!range) {
+          continue;
+        }
+
+        context.report({
+          node: typeNode,
+          messageId: 'flattenParentheses',
+          data: { operatorType },
+          fix(fixer) {
+            // Use text between parens (exclusive) to preserve any interleaved comments
+            const innerText = sourceCode.text.slice(range[0] + 1, range[1] - 1).trimStart();
+            return fixer.replaceTextRange(range, innerText);
+          },
+        });
+      }
+    }
+
+    return {
+      TSUnionType: checkNode,
+      TSIntersectionType: checkNode,
+    };
+  },
+});

package/src/eslint/mui/rules/flatten-parentheses.test.mjs

@@ -0,0 +1,234 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import TSESlintParser from '@typescript-eslint/parser';
+import rule from './flatten-parentheses.mjs';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: TSESlintParser,
+  },
+});
+
+ruleTester.run('flatten-parentheses', rule, {
+  valid: [
+    // Simple union without parentheses
+    `type T = 1 | 2 | 3;`,
+
+    // Simple intersection without parentheses
+    `type T = A & B & C;`,
+
+    // Parentheses around single type (not in union/intersection context)
+    `type T = (string);`,
+
+    // Parentheses needed for precedence (intersection inside union)
+    `type T = (A & B) | C;`,
+
+    // Parentheses needed for precedence (union inside intersection)
+    `type T = (A | B) & C;`,
+
+    // Complex nested structure where parentheses change meaning
+    `type T = (A | B) & (C | D);`,
+
+    // Function types where parentheses are needed
+    `type T = (() => void) | string;`,
+
+    // Array types
+    `type T = (string | number)[];`,
+
+    // Generic types
+    `type T = Promise<string | number>;`,
+
+    // Mixed operators - parentheses are needed
+    `type T = A | (B & C);`,
+    `type T = (A | B) & (C | D) | E;`,
+  ],
+  invalid: [
+    // Basic union flattening - example from the problem statement
+    {
+      code: `type T = (1 | 2 | 3) | 4;`,
+      output: `type T = 1 | 2 | 3 | 4;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+          column: 11,
+        },
+      ],
+    },
+
+    // Union on the right side
+    {
+      code: `type T = 1 | (2 | 3 | 4);`,
+      output: `type T = 1 | 2 | 3 | 4;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Multiple parenthesized unions
+    {
+      code: `type T = (1 | 2) | (3 | 4);`,
+      output: `type T = 1 | 2 | 3 | 4;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Intersection flattening
+    {
+      code: `type T = (A & B & C) & D;`,
+      output: `type T = A & B & C & D;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Intersection on the right
+    {
+      code: `type T = A & (B & C & D);`,
+      output: `type T = A & B & C & D;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Multiple parenthesized intersections
+    {
+      code: `type T = (A & B) & (C & D);`,
+      output: `type T = A & B & C & D;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // With type aliases
+    {
+      code: `type Union = (string | number) | boolean;`,
+      output: `type Union = string | number | boolean;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // In type parameters
+    {
+      code: `type T<U> = (U | null) | undefined;`,
+      output: `type T<U> = U | null | undefined;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // With whitespace (trailing space left for Prettier to clean up)
+    {
+      code: `type T = ( A | B ) | C;`,
+      output: `type T = A | B  | C;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Nested unions - multiple fix passes needed due to overlapping ranges
+    {
+      code: `type T = ((A | B) | C) | D;`,
+      output: [`type T = (A | B) | C | D;`, `type T = A | B | C | D;`],
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Complex type names
+    {
+      code: `type Result = (Success<Data> | Error<Message>) | Loading;`,
+      output: `type Result = Success<Data> | Error<Message> | Loading;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+          line: 1,
+        },
+      ],
+    },
+
+    // Multiline union (Prettier cleans up extra whitespace)
+    {
+      code: `type T = (\n  A | B\n) | C;`,
+      output: `type T = A | B\n | C;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+        },
+      ],
+    },
+
+    // Leading block comment inside parentheses - preserved in output
+    {
+      code: `type T = (/* comment */ A | B) | C;`,
+      output: `type T = /* comment */ A | B | C;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+        },
+      ],
+    },
+
+    // Trailing block comment inside parentheses - preserved in output
+    {
+      code: `type T = (A | B /* comment */) | C;`,
+      output: `type T = A | B /* comment */ | C;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+        },
+      ],
+    },
+
+    // Trailing line comment - newline preserved so | C continues on next line
+    {
+      code: `type T = (A | B // comment\n) | C;`,
+      output: `type T = A | B // comment\n | C;`,
+      errors: [
+        {
+          messageId: 'flattenParentheses',
+        },
+      ],
+    },
+  ],
+});