@mui/internal-code-infra 0.0.4-canary.61 → 0.0.4-canary.63

package/build/utils/pnpm.d.mts

@@ -135,6 +135,19 @@ export declare function readPackageJson(packagePath: string): Promise<import('..
  * @returns {Promise<void>}
  */
 export declare function writePackageJson(packagePath: string, packageJson: Object): Promise<void>;
+/**
+ * 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 declare function writeOverridesToWorkspace(workspaceDir: string, overrides: Record<string, string>): Promise<void>;
 /**
  * Resolve a package@version specifier to an exact version
  * @param {string} packageSpec - Package specifier in format "package@version"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.4-canary.61",
+  "version": "0.0.4-canary.63",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -138,6 +138,7 @@
     "unified": "^11.0.5",
     "unified-lint-rule": "^3.0.1",
     "unist-util-visit": "^5.1.0",
+    "yaml": "^2.9.0",
     "yargs": "^18.0.0",
     "@mui/internal-babel-plugin-display-name": "1.0.4-canary.20",
     "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.27",
@@ -191,7 +192,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "6c77485e850c4bb78f9c999a3483093e2bc79c06",
+  "gitSha": "e08081fbb9ce12311a1acb555f69108dc1231951",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/cli/cmdSetVersionOverrides.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import * as semver from 'semver';
 import { $ } from 'execa';
-import { resolveVersion, findDependencyVersionFromSpec } from '../utils/pnpm.mjs';
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
+import {
+  resolveVersion,
+  findDependencyVersionFromSpec,
+  writeOverridesToWorkspace,
+} from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args
@@ -103,11 +105,8 @@ async function handler(args) {
   // eslint-disable-next-line no-console
   console.log(`Using overrides: ${JSON.stringify(overrides, null, 2)}`);
 
-  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: 'utf8' }));
-  packageJson.resolutions ??= {};
-  Object.assign(packageJson.resolutions, overrides);
-  await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}${os.EOL}`);
+  const workspaceDir = (await findWorkspaceDir(process.cwd())) ?? process.cwd();
+  await writeOverridesToWorkspace(workspaceDir, overrides);
 
   await $({ stdio: 'inherit' })`pnpm dedupe`;
 }

package/src/utils/build.test.mjs

@@ -1281,4 +1281,77 @@ describe('createPackageImports', () => {
       },
     });
   });
+
+  it('passes a conditions object of bare specifiers through unchanged, preserving condition order', async () => {
+    const cwd = await makeTempDir();
+
+    const imports = await createPackageImports(
+      {
+        '#mui/TransitionGroupContext': {
+          node: 'react-transition-group/cjs/TransitionGroupContext.js',
+          browser: 'react-transition-group/esm/TransitionGroupContext.js',
+          default: 'react-transition-group/esm/TransitionGroupContext.js',
+        },
+      },
+      {
+        bundles: [
+          { type: 'esm', dir: '.' },
+          { type: 'cjs', dir: '.' },
+        ],
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#mui/TransitionGroupContext': {
+        node: 'react-transition-group/cjs/TransitionGroupContext.js',
+        browser: 'react-transition-group/esm/TransitionGroupContext.js',
+        default: 'react-transition-group/esm/TransitionGroupContext.js',
+      },
+    });
+    expect(
+      Object.keys(
+        /** @type {Record<string, unknown>} */ (imports?.['#mui/TransitionGroupContext']),
+      ),
+    ).toEqual(['node', 'browser', 'default']);
+  });
+
+  it('passes a nested import/require/default object of bare specifiers through unchanged', async () => {
+    const cwd = await makeTempDir();
+
+    const imports = await createPackageImports(
+      {
+        '#mui/TransitionGroupContext': {
+          node: 'react-transition-group/cjs/TransitionGroupContext.js',
+          default: {
+            import: 'react-transition-group/esm/TransitionGroupContext.js',
+            require: 'react-transition-group/cjs/TransitionGroupContext.js',
+            default: 'react-transition-group/esm/TransitionGroupContext.js',
+          },
+        },
+      },
+      {
+        bundles: [
+          { type: 'esm', dir: '.' },
+          { type: 'cjs', dir: '.' },
+        ],
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#mui/TransitionGroupContext': {
+        node: 'react-transition-group/cjs/TransitionGroupContext.js',
+        default: {
+          import: 'react-transition-group/esm/TransitionGroupContext.js',
+          require: 'react-transition-group/cjs/TransitionGroupContext.js',
+          default: 'react-transition-group/esm/TransitionGroupContext.js',
+        },
+      },
+    });
+  });
 });

package/src/utils/pnpm.mjs

@@ -5,6 +5,7 @@ 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
@@ -385,6 +386,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/pnpm.test.mjs

@@ -3,7 +3,12 @@ import * as path from 'node:path';
 import { describe, it, expect } from 'vitest';
 
 import { makeTempDir } from './testUtils.mjs';
-import { checkPublishDependencies } from './pnpm.mjs';
+import {
+  checkPublishDependencies,
+  readPackageJson,
+  writePackageJson,
+  writeOverridesToWorkspace,
+} from './pnpm.mjs';
 
 /**
  * Write a package.json file to a temp subdirectory and return the directory path.
@@ -578,3 +583,149 @@ describe('checkPublishDependencies', () => {
     });
   });
 });
+
+/**
+ * Set up a temp workspace with a package.json and optional pnpm-workspace.yaml.
+ * @param {object} packageJson - package.json contents
+ * @param {string} [workspaceYaml] - pnpm-workspace.yaml contents, omitted to skip the file
+ * @returns {Promise<string>} The workspace directory
+ */
+async function makeWorkspace(packageJson, workspaceYaml) {
+  const cwd = await makeTempDir();
+  const writes = [writePackageJson(cwd, packageJson)];
+  if (workspaceYaml !== undefined) {
+    writes.push(fs.writeFile(path.join(cwd, 'pnpm-workspace.yaml'), workspaceYaml));
+  }
+  await Promise.all(writes);
+  return cwd;
+}
+
+/**
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+function readWorkspaceYaml(cwd) {
+  return fs.readFile(path.join(cwd, 'pnpm-workspace.yaml'), 'utf8');
+}
+
+describe('writeOverridesToWorkspace', () => {
+  describe('writing to pnpm-workspace.yaml', () => {
+    it('creates the file with an overrides block when none exists', async () => {
+      const cwd = await makeWorkspace({ name: 'root' });
+
+      await writeOverridesToWorkspace(cwd, { foo: '1.2.3' });
+
+      expect(await readWorkspaceYaml(cwd)).toMatchInlineSnapshot(`
+        "overrides:
+          foo: 1.2.3
+        "
+      `);
+    });
+
+    it('merges into an existing block, preserving comments and quoting scoped names', async () => {
+      const cwd = await makeWorkspace(
+        { name: 'root' },
+        [
+          'packages:',
+          "  - 'packages/*'",
+          'overrides:',
+          '  # keep this pin',
+          "  bar: '2.0.0'",
+          '',
+        ].join('\n'),
+      );
+
+      await writeOverridesToWorkspace(cwd, { playwright: '1.49.1', '@playwright/test': '1.49.1' });
+
+      expect(await readWorkspaceYaml(cwd)).toMatchInlineSnapshot(`
+        "packages:
+          - 'packages/*'
+        overrides:
+          # keep this pin
+          bar: '2.0.0'
+          playwright: 1.49.1
+          "@playwright/test": 1.49.1
+        "
+      `);
+      // The package.json is left untouched.
+      expect(await readPackageJson(cwd)).toEqual({ name: 'root' });
+    });
+
+    it('overwrites a same-named override, keeping its quote style', async () => {
+      const cwd = await makeWorkspace(
+        { name: 'root' },
+        ['overrides:', "  foo: '1.0.0'", ''].join('\n'),
+      );
+
+      await writeOverridesToWorkspace(cwd, { foo: '2.0.0' });
+
+      expect(await readWorkspaceYaml(cwd)).toMatchInlineSnapshot(`
+        "overrides:
+          foo: '2.0.0'
+        "
+      `);
+    });
+
+    it('prefers the workspace file when both manifests define overrides', async () => {
+      const cwd = await makeWorkspace(
+        { name: 'root', pnpm: { overrides: { baz: '3.0.0' } } },
+        ['overrides:', "  bar: '2.0.0'", ''].join('\n'),
+      );
+
+      await writeOverridesToWorkspace(cwd, { foo: '1.2.3' });
+
+      expect(await readWorkspaceYaml(cwd)).toContain('foo: 1.2.3');
+      // package.json overrides are left where they were.
+      expect(await readPackageJson(cwd)).toEqual({
+        name: 'root',
+        pnpm: { overrides: { baz: '3.0.0' } },
+      });
+    });
+  });
+
+  describe('writing to package.json', () => {
+    it('honors the package.json location when no workspace overrides exist', async () => {
+      const cwd = await makeWorkspace({
+        name: 'root',
+        pnpm: { overrides: { foo: '1.0.0' }, packageExtensions: { thing: {} } },
+      });
+
+      await writeOverridesToWorkspace(cwd, { bar: '2.0.0' });
+
+      expect(await readPackageJson(cwd)).toEqual({
+        name: 'root',
+        pnpm: { overrides: { foo: '1.0.0', bar: '2.0.0' }, packageExtensions: { thing: {} } },
+      });
+      // No workspace file is created.
+      await expect(fs.access(path.join(cwd, 'pnpm-workspace.yaml'))).rejects.toThrow();
+    });
+
+    it('lets computed overrides win over an existing package.json override', async () => {
+      const cwd = await makeWorkspace({ name: 'root', pnpm: { overrides: { foo: '1.0.0' } } });
+
+      await writeOverridesToWorkspace(cwd, { foo: '2.0.0' });
+
+      expect(await readPackageJson(cwd)).toEqual({
+        name: 'root',
+        pnpm: { overrides: { foo: '2.0.0' } },
+      });
+    });
+  });
+
+  describe('rejecting resolutions', () => {
+    it('throws and writes nothing when package.json has a resolutions field', async () => {
+      const cwd = await makeWorkspace({ name: 'root', resolutions: { foo: '1.0.0' } });
+
+      await expect(writeOverridesToWorkspace(cwd, { bar: '2.0.0' })).rejects.toThrow(/resolutions/);
+      await expect(fs.access(path.join(cwd, 'pnpm-workspace.yaml'))).rejects.toThrow();
+    });
+
+    it('ignores an empty resolutions field', async () => {
+      const cwd = await makeWorkspace({ name: 'root', resolutions: {} });
+
+      await writeOverridesToWorkspace(cwd, { foo: '1.2.3' });
+
+      expect(await readWorkspaceYaml(cwd)).toContain('foo: 1.2.3');
+    });
+  });
+});