@mui/internal-code-infra 0.0.4-canary.99 → 0.1.1-canary.1

package/src/utils/extractErrorCodes.mjs

@@ -6,9 +6,12 @@ import minifyErrorsPlugin from '@mui/internal-babel-plugin-minify-errors';
 import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { mapAsync } from 'es-toolkit/array';
 
 import { getWorkspacePackages } from './pnpm.mjs';
-import { BASE_IGNORES, mapConcurrently } from './build.mjs';
+import { BASE_IGNORES } from './build.mjs';
+
+const PLAIN_TS_EXTENSION = /\.[cm]?ts$/;
 
 /**
  * @typedef {Object} Args
@@ -51,18 +54,20 @@ async function getFilesForPackage(pkg) {
  * @param {Set<string | Error>} errors
  * @param {import('@mui/internal-babel-plugin-minify-errors').Options['detection']} [detection='opt-in']
  */
-async function extractErrorCodesForWorkspace(files, errors, detection = 'opt-in') {
-  await mapConcurrently(
+export async function extractErrorCodesForFiles(files, errors, detection = 'opt-in') {
+  await mapAsync(
     files,
     async (fullPath) => {
       const code = await fs.readFile(fullPath, 'utf8');
+      // Plain .ts files must not get the JSX parser: `<T = unknown>(x) => x` would be read as JSX.
+      const isPlainTs = PLAIN_TS_EXTENSION.test(fullPath);
       // Replicate how Babel is run when preparing the source to be published on npm, so we can extract the same messages.
       await transformAsync(code, {
         filename: fullPath,
         sourceType: 'module',
         plugins: [
-          [babelSyntaxTypescript, { isTSX: true }],
-          [babelSyntaxJsx],
+          [babelSyntaxTypescript, { isTSX: !isPlainTs }],
+          ...(isPlainTs ? [] : [babelSyntaxJsx]),
           [minifyErrorsPlugin, { collectErrors: errors, detection }],
         ],
         configFile: false,
@@ -71,7 +76,7 @@ async function extractErrorCodesForWorkspace(files, errors, detection = 'opt-in'
         code: false,
       });
     },
-    30,
+    { concurrency: 30 },
   );
 }
 
@@ -108,7 +113,7 @@ export default async function extractErrorCodes(args) {
   // Extract error codes from said files.
   const filesToProcess = files.flat();
   console.log(`🔍 Extracting error codes from ${filesToProcess.length} files...`);
-  await extractErrorCodesForWorkspace(filesToProcess, errors, detection);
+  await extractErrorCodesForFiles(filesToProcess, errors, detection);
 
   // Partition collected entries into valid messages and unminifyable errors.
   /** @type {string[]} */

package/src/utils/pnpm.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+import { getPublishedByPolicy } from '@pnpm/config.version-policy';
+import { parseWantedDependency } from '@pnpm/parse-wanted-dependency';
 import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
 import * as fs from 'node:fs/promises';
@@ -160,6 +162,21 @@ export async function getPublishRegistry(packagePath) {
   return registryUrl.href;
 }
 
+/**
+ * Get the version to release from the workspace-root package.json.
+ *
+ * Resolves the workspace root so the version is the monorepo's regardless of
+ * which directory publish runs from.
+ *
+ * @param {string} [cwd] - Directory to resolve the workspace root from
+ * @returns {Promise<string | null>} Version string, or null when absent/invalid
+ */
+export async function getReleaseVersion(cwd = process.cwd()) {
+  const workspaceDir = (await findWorkspaceDir(cwd)) ?? cwd;
+  const { version } = await readPackageJson(workspaceDir);
+  return version ? semver.valid(version) : null;
+}
+
 /**
  * Whether a registry requires a package to exist before CI can publish to it.
  * @param {string} registry - Normalized registry URL
@@ -313,10 +330,10 @@ function aliasTarget(spec) {
   if (!spec.startsWith('workspace:')) {
     return null;
   }
-  const range = spec.slice('workspace:'.length);
-  // Search from 1 so a scoped name's own leading `@` isn't read as the separator.
-  const separator = range.indexOf('@', 1);
-  return separator === -1 ? null : range.slice(0, separator);
+  const { alias, bareSpecifier } = parseWantedDependency(spec.slice('workspace:'.length));
+  // A plain range parses as one half or the other (`*` as an alias, `^1.0.0` as a
+  // specifier); only an aliased spec carries both.
+  return bareSpecifier === undefined ? null : (alias ?? null);
 }
 
 /**
@@ -705,26 +722,209 @@ export async function renameWorkspaceScope(packages, fromScope, toScope) {
 }
 
 /**
- * Resolve a package@version specifier to an exact version
+ * The versions a `minimumReleaseAgeExclude` policy exempts from the cooldown. A
+ * policy answers `true` for a package that is exempt at any version, or the list
+ * of versions exempted individually.
+ *
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Policy from {@link getMinimumReleaseAgePolicy}
+ * @param {string} name - Package name
+ * @returns {true | string[]} `true` when every version is exempt, otherwise the exempt versions
+ */
+function cooldownExemptions(policy, name) {
+  const exemption = policy.publishedByExclude?.(name);
+  if (exemption === true) {
+    return true;
+  }
+  return Array.isArray(exemption) ? exemption : [];
+}
+
+/**
+ * Pick the version to pin for a specifier whose newest match is too recent to
+ * satisfy a `minimumReleaseAge` cooldown.
+ *
+ * Only the three specifier shapes this tool is given are handled. An exact
+ * version is not a choice, so it stands and the install reports it. A range
+ * resolves within itself. A dist-tag repoints to the highest aged-in version
+ * sharing the major and prerelease-ness — except `latest`, which pnpm allows to
+ * cross majors. Unlike pnpm, a deprecated version is not passed over: `pnpm info`
+ * lists bare version strings, so that flag would cost a request per candidate.
+ *
+ * @param {string} requested - The specifier as given: a dist-tag, range or exact version
+ * @param {string} resolvedVersion - Version the specifier resolves to today
+ * @param {string[]} versions - Every published version, from `pnpm info <pkg> versions`
+ * @param {Record<string, string>} publishTimes - Version to ISO publish date, from `pnpm info <pkg> time`
+ * @param {number} cutoff - Epoch ms; versions published after this are too recent
+ * @param {string[]} [exemptVersions] - Versions `minimumReleaseAgeExclude` installs regardless of age
+ * @returns {string | null} Version to pin, or null when nothing qualifies
+ * @internal exported for unit tests
+ */
+export function selectAgedVersion(
+  requested,
+  resolvedVersion,
+  versions,
+  publishTimes,
+  cutoff,
+  exemptVersions = [],
+) {
+  const exempt = new Set(exemptVersions);
+
+  /**
+   * Whether the install would accept this version: old enough, or excluded from
+   * the cooldown altogether.
+   *
+   * @param {string} version
+   * @returns {boolean}
+   */
+  const isInstallable = (version) => {
+    if (exempt.has(version)) {
+      return true;
+    }
+    const published = Date.parse(publishTimes[version]);
+    return Number.isFinite(published) && published <= cutoff;
+  };
+
+  // An unknown publish date leaves nothing to compare against, so the
+  // resolution stands rather than being swapped for another build.
+  if (!Object.hasOwn(publishTimes, resolvedVersion) || isInstallable(resolvedVersion)) {
+    return resolvedVersion;
+  }
+
+  if (semver.valid(requested)) {
+    return resolvedVersion;
+  }
+
+  // `time` keeps an entry for a version after it is unpublished, so candidates
+  // come from the version list rather than from the dates.
+  const candidates = versions.filter(isInstallable);
+
+  if (semver.validRange(requested)) {
+    return semver.maxSatisfying(candidates, requested, true);
+  }
+
+  const resolved = semver.parse(resolvedVersion, true);
+  if (!resolved) {
+    return resolvedVersion;
+  }
+  const resolvedIsPrerelease = resolved.prerelease.length > 0;
+
+  let best = null;
+  for (const version of candidates) {
+    const parsed = semver.parse(version, true);
+    if (
+      !parsed ||
+      (requested !== 'latest' && parsed.major !== resolved.major) ||
+      parsed.prerelease.length > 0 !== resolvedIsPrerelease
+    ) {
+      continue;
+    }
+    if (!best || semver.gt(version, best, true)) {
+      best = version;
+    }
+  }
+  return best;
+}
+
+/**
+ * Read the effective pnpm configuration, including everything resolved from
+ * pnpm-workspace.yaml. `config list` types the values and omits unset keys,
+ * where `config get` stringifies everything and prints `undefined`.
+ *
+ * @returns {Promise<Record<string, any>>} Parsed configuration
+ */
+export async function readPnpmConfig() {
+  const result = await $`pnpm config list --json`;
+  return JSON.parse(result.stdout);
+}
+
+/**
+ * Read the registry cooldown from pnpm config, so resolution stays in step with
+ * what the subsequent install will enforce.
+ *
+ * @returns {Promise<import('@pnpm/config.version-policy').PublishedByPolicy>} Cutoff date and exemption policy, both undefined when no cooldown is configured
+ */
+export async function getMinimumReleaseAgePolicy() {
+  const config = await readPnpmConfig();
+  // pnpm's own parser, so exclude entries keep their full grammar — wildcards,
+  // version unions (`pkg@1.0.0 || 2.0.0`) and `!` negation.
+  return getPublishedByPolicy({
+    minimumReleaseAge: config.minimumReleaseAge,
+    minimumReleaseAgeExclude: config.minimumReleaseAgeExclude,
+  });
+}
+
+/**
+ * Resolve a package@version specifier to an exact version.
+ *
+ * Given a cooldown policy, the result is the newest version the install will
+ * actually accept — a dist-tag on a daily channel always points at a build too
+ * recent to install under one. See {@link selectAgedVersion}.
+ *
  * @param {string} packageSpec - Package specifier in format "package@version"
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Cooldown from {@link getMinimumReleaseAgePolicy}
  * @returns {Promise<string>} Exact version string
  */
-export async function resolveVersion(packageSpec) {
-  const result = await $`pnpm info ${packageSpec} version --json`;
-  const versions = JSON.parse(result.stdout);
-  return typeof versions === 'string' ? versions : versions[versions.length - 1];
+export async function resolveVersion(packageSpec, policy) {
+  // The unprojected document carries both the resolved version and every
+  // publish date, so honouring the cooldown costs no extra round-trip.
+  const info = JSON.parse((await $`pnpm info ${packageSpec} --json`).stdout);
+  const manifest = Array.isArray(info) ? info[info.length - 1] : info;
+  const { name, version: exactVersion, time: publishTimes = {}, versions = [] } = manifest;
+
+  if (!policy.publishedBy) {
+    return exactVersion;
+  }
+
+  const exemptVersions = cooldownExemptions(policy, name);
+  if (exemptVersions === true || exemptVersions.includes(exactVersion)) {
+    return exactVersion;
+  }
+
+  const cutoff = policy.publishedBy.toISOString();
+  const { bareSpecifier: requested } = parseWantedDependency(packageSpec);
+  const agedVersion = selectAgedVersion(
+    requested ?? '',
+    exactVersion,
+    versions,
+    publishTimes,
+    policy.publishedBy.getTime(),
+    exemptVersions,
+  );
+
+  if (!agedVersion) {
+    throw new Error(
+      `No version matching ${packageSpec} was published before the minimumReleaseAge cutoff ` +
+        `(${cutoff}). The newest match, ${exactVersion}, was published at ` +
+        `${publishTimes[exactVersion]}, and no earlier match qualifies. Lower ` +
+        `minimumReleaseAge, add ${name} to minimumReleaseAgeExclude, or wait for ${exactVersion} ` +
+        `to age in.`,
+    );
+  }
+
+  if (agedVersion !== exactVersion) {
+    // eslint-disable-next-line no-console
+    console.log(
+      `Resolved ${packageSpec} to ${agedVersion} rather than ${exactVersion}, which was published after the minimumReleaseAge cutoff (${cutoff}).`,
+    );
+  }
+
+  return agedVersion;
 }
 
 /**
  * Find the version of a dependency for a specific package@version
+ *
+ * The parent's spec is often a range, so the cooldown applies here too. Stepping
+ * back stays within that range and so never contradicts the parent.
+ *
  * @param {string} packageSpec - Package specifier in format "package@version"
  * @param {string} dependency - Dependency name to look up
+ * @param {import('@pnpm/config.version-policy').PublishedByPolicy} policy - Registry cooldown to resolve within
  * @returns {Promise<string>} Exact version string of the dependency
  */
-export async function findDependencyVersionFromSpec(packageSpec, dependency) {
+export async function findDependencyVersionFromSpec(packageSpec, dependency, policy) {
   const result = await $`pnpm info ${packageSpec} dependencies.${dependency}`;
   const spec = result.stdout.trim();
-  return resolveVersion(`${dependency}@${spec}`);
+  return resolveVersion(`${dependency}@${spec}`, policy);
 }
 
 /**

package/src/utils/typescript.mjs

@@ -9,26 +9,49 @@ import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { getOutExtension, mapConcurrently } from '../utils/build.mjs';
+import { mapAsync } from 'es-toolkit/array';
+import { getOutExtension } from '../utils/build.mjs';
 
 const $$ = $({ stdio: 'inherit' });
 
 /**
- * Checks if tsgo CLI is available in the workspace's node_modules.
- * @param {string} cwd - The current working directory to start searching from.
- * @returns {Promise<string | null>} - The path to tsgo if found, null otherwise.
+ * Finds a CLI shim in a directory's node_modules/.bin.
+ * @param {string} dir
+ * @param {string} name
+ * @returns {Promise<string | null>}
  */
-async function findTsgo(cwd) {
-  const workspaceDir = await findWorkspaceDir(cwd);
-  if (!workspaceDir) {
-    return null;
-  }
-  const tsgoPath = path.join(workspaceDir, 'node_modules', '.bin', 'tsgo');
-  const exists = await fs.stat(tsgoPath).then(
+async function findBin(dir, name) {
+  const binPath = path.join(dir, 'node_modules', '.bin', name);
+  const exists = await fs.stat(binPath).then(
     (stat) => stat.isFile(),
     () => false,
   );
-  return exists ? tsgoPath : null;
+  return exists ? binPath : null;
+}
+
+/**
+ * Resolves the native/JS TypeScript CLI pair from the workspace root's
+ * `node_modules/.bin`: tsgo/tsc when the legacy `tsgo` shim exists, tsc/tsc6
+ * otherwise, with bare `tsc` from PATH as the JS fallback.
+ *
+ * @param {string} cwd
+ * @returns {Promise<{ native: string | null, js: string }>}
+ */
+async function findTscPair(cwd) {
+  const workspaceDir = await findWorkspaceDir(cwd);
+  if (!workspaceDir) {
+    return { native: null, js: 'tsc' };
+  }
+
+  const [tsgo, tsc, tsc6] = await Promise.all([
+    findBin(workspaceDir, 'tsgo'),
+    findBin(workspaceDir, 'tsc'),
+    findBin(workspaceDir, 'tsc6'),
+  ]);
+  if (tsgo) {
+    return { native: tsgo, js: 'tsc' };
+  }
+  return { native: tsc, js: tsc6 ?? 'tsc' };
 }
 
 /**
@@ -36,44 +59,38 @@ async function findTsgo(cwd) {
  * @param {string} tsconfig - The path to the tsconfig.json file.
  * @param {string} outDir - The output directory for the declaration files.
  * @param {Object} options
- * @param {boolean} [options.useTsgo] - Whether to use typescript native (tsgo).
+ * @param {boolean} [options.useTsgo] - Whether to use the native TypeScript compiler.
  */
 export async function emitDeclarations(tsconfig, outDir, options) {
   const { useTsgo = false } = options ?? {};
   const tsconfigDir = path.dirname(tsconfig);
   const rootDir = path.resolve(tsconfigDir, './src');
 
-  const tsgoPath = useTsgo ? await findTsgo(tsconfigDir) : null;
+  const pair = await findTscPair(tsconfigDir);
+  const tsgoPath = useTsgo ? pair.native : null;
   if (useTsgo && !tsgoPath) {
     throw new Error(
-      '--tsgo flag was passed or MUI_USE_TSGO environment was set but no tsgo cli was found. Either remove the flag to use tsc or install the native package "@typescript/native-preview" at the workspace level to use tsgo.',
+      '--tsgo flag was passed but no native TypeScript cli was found. Either remove the flag to use the JS compiler or install TypeScript 7 at the workspace root, as "typescript@^7" or under an alias such as "@typescript/native".',
     );
   }
 
-  if (tsgoPath) {
-    console.log('Using tsgo for declaration emit');
-    await $$`${tsgoPath}
-      -p ${tsconfig}
-      --rootDir ${rootDir}
-      --outDir ${outDir}
-      --declaration
-      --emitDeclarationOnly
-      --noEmit false
-      --composite false
-      --incremental false
-      --declarationMap false`;
-  } else {
-    await $$`tsc
-      -p ${tsconfig}
-      --rootDir ${rootDir}
-      --outDir ${outDir}
-      --declaration
-      --emitDeclarationOnly
-      --noEmit false
-      --composite false
-      --incremental false
-      --declarationMap false`;
-  }
+  const tscPath = tsgoPath ?? pair.js;
+  console.log(
+    tsgoPath
+      ? `Using ts-native for declaration emit: ${tscPath}`
+      : `Using ${tscPath} for declaration emit`,
+  );
+
+  await $$`${tscPath}
+    -p ${tsconfig}
+    --rootDir ${rootDir}
+    --outDir ${outDir}
+    --declaration
+    --emitDeclarationOnly
+    --noEmit false
+    --composite false
+    --incremental false
+    --declarationMap false`;
 }
 
 /**
@@ -129,7 +146,7 @@ export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles
     return;
   }
 
-  await mapConcurrently(
+  await mapAsync(
     dtsFiles,
     async (dtsFile) => {
       // Normalize to native separators to make path comparisons reliable on Windows
@@ -160,6 +177,7 @@ export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles
           const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
           const outFilePath = path.join(buildDir, outFileRelative);
 
+          /** @type {import('@babel/core').PluginItem[]} */
           const babelPlugins = [
             [pluginTypescriptSyntax, { dts: true }],
             [pluginResolveImports, { outExtension: importExtension }],
@@ -182,7 +200,7 @@ export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles
         await fs.unlink(nativeDtsFile);
       }
     },
-    30,
+    { concurrency: 30 },
   );
 }
 
@@ -198,7 +216,7 @@ export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles
  * @param {string} param0.buildDir - The build directory.
  * @param {string} param0.cwd - The current working directory.
  * @param {boolean} param0.skipTsc - Whether to skip running TypeScript compiler (tsc) for building types.
- * @param {boolean} [param0.useTsgo=false] - Whether to build types using typescript native (tsgo).
+ * @param {boolean} [param0.useTsgo=false] - Whether to build types using the native TypeScript compiler.
  * @param {'module' | 'commonjs'} [param0.packageType] - The package.json type field.
  */
 export async function createTypes({