@mui/internal-code-infra 0.0.4-canary.62 → 0.0.4-canary.64

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.62",
+  "version": "0.0.4-canary.64",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -138,10 +138,11 @@
     "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-resolve-imports": "2.0.7-canary.36",
+    "@mui/internal-babel-plugin-display-name": "1.0.4-canary.20",
     "@mui/internal-babel-plugin-minify-errors": "2.0.8-canary.27",
-    "@mui/internal-babel-plugin-display-name": "1.0.4-canary.20"
+    "@mui/internal-babel-plugin-resolve-imports": "2.0.7-canary.36"
   },
   "peerDependencies": {
     "@next/eslint-plugin-next": "*",
@@ -191,7 +192,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "ca1c0b42f26266f8a75b7075025a98a6ceb091c7",
+  "gitSha": "42ab800dc8926bfe1c6ea3020a013565143f1bd6",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/brokenLinksChecker/index.mjs

@@ -9,6 +9,7 @@ import { Transform } from 'node:stream';
 import { Worker } from 'node:worker_threads';
 
 const DEFAULT_CONCURRENCY = 4;
+const SERVER_START_TIMEOUT = 10000;
 
 const crawlWorkerUrl = new URL('./crawlWorker.mjs', import.meta.url);
 
@@ -620,30 +621,56 @@ export async function crawl(rawOptions) {
 
   /** @type {AbortController | null} */
   let controller = null;
-  if (options.startCommand) {
-    console.log(chalk.blue(`Starting server with "${options.startCommand}"...`));
-    controller = new AbortController();
-    const appProcess = execaCommand(options.startCommand, {
-      stdout: 'pipe',
-      stderr: 'pipe',
-      cancelSignal: controller.signal,
-      env: {
-        FORCE_COLOR: '1',
-        ...process.env,
-      },
-    });
 
-    // Prefix server logs
-    const serverPrefix = chalk.gray('server: ');
-    appProcess.stdout.pipe(prefixLines(serverPrefix)).pipe(process.stdout);
-    appProcess.stderr.pipe(prefixLines(serverPrefix)).pipe(process.stderr);
-    appProcess.catch(() => {});
+  try {
+    if (options.startCommand) {
+      console.log(chalk.blue(`Starting server with "${options.startCommand}"...`));
+      controller = new AbortController();
+      const appProcess = execaCommand(options.startCommand, {
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cancelSignal: controller.signal,
+        env: {
+          FORCE_COLOR: '1',
+          ...process.env,
+        },
+      });
+
+      // Prefix server logs
+      const serverPrefix = chalk.gray('server: ');
+      appProcess.stdout.pipe(prefixLines(serverPrefix)).pipe(process.stdout);
+      appProcess.stderr.pipe(prefixLines(serverPrefix)).pipe(process.stderr);
+      appProcess.catch(() => {});
 
-    await pollUrl(options.host, 10000);
+      // Poll the first page we are about to crawl (resolved against host) so we
+      // wait for the actual entry point to be serveable rather than the
+      // homepage, which may be a different (slower) page.
+      const healthcheckUrl = new URL(options.seedUrls[0] ?? '/', options.host).href;
+      await pollUrl(healthcheckUrl, SERVER_START_TIMEOUT);
 
-    console.log(`Server started on ${chalk.underline(options.host)}`);
+      console.log(`Server started on ${chalk.underline(options.host)}`);
+    }
+
+    return await runCrawl(options, startTime);
+  } finally {
+    // Always stop the server, even when startup or crawling throws. Without
+    // this, a failed healthcheck (or any error) would leave the dev server
+    // running, which on slow environments (e.g. Netlify) leads to orphaned
+    // servers piling up across retries.
+    if (controller) {
+      console.log(chalk.blue('Stopping server...'));
+      controller.abort();
+    }
   }
+}
 
+/**
+ * Runs the crawl against an already-running server.
+ * @param {ResolvedCrawlOptions} options - Fully resolved crawl options
+ * @param {number} startTime - Timestamp (ms) when the crawl began, for duration reporting
+ * @returns {Promise<CrawlResult>} Crawl results including all links, pages, and issues found
+ */
+async function runCrawl(options, startTime) {
   const knownTargets = await resolveKnownTargets(options);
 
   /** @type {Map<string, Promise<PageData>>} */
@@ -733,11 +760,6 @@ export async function crawl(rawOptions) {
 
   await queue.waitAll();
 
-  if (controller) {
-    console.log(chalk.blue('Stopping server...'));
-    controller.abort();
-  }
-
   const results = new Map(
     await Promise.all(
       Array.from(crawledPages.entries(), async ([a, b]) => /** @type {const} */ ([a, await b])),

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/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');
+    });
+  });
+});