@mui/internal-code-infra 0.1.1-canary.2 → 0.1.1-canary.21

package/src/utils/build.mjs

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import getTargets from '@babel/helper-compilation-targets';
 import { globby } from 'globby';
 import * as semver from 'semver';
 
@@ -867,6 +868,39 @@ export function validatePkgJson(packageJson, options = {}) {
   }
 }
 
+/**
+ * Validates that "engines.node" in package.json doesn't allow Node.js versions older than the
+ * "node" browserslist environment, which the CommonJS bundle is compiled for. Otherwise the
+ * build can emit syntax that the oldest supported Node.js version can't run.
+ * Targets are resolved the same way `@babel/preset-env` resolves them during the build.
+ * @param {{ name?: string; engines?: { node?: string } }} packageJson
+ * @param {string} cwd - The package directory, used to find the browserslist config.
+ */
+export function validateEnginesNode(packageJson, cwd) {
+  const enginesNode = packageJson.engines?.node;
+  if (!enginesNode) {
+    return;
+  }
+
+  const minEnginesVersion = semver.minVersion(enginesNode);
+  if (!minEnginesVersion) {
+    throw new Error(
+      `Unable to determine the minimum Node.js version from "engines.node" in "${packageJson.name}" package.json: "${enginesNode}".`,
+    );
+  }
+
+  const targetNode = getTargets(undefined, { configPath: cwd, browserslistEnv: 'node' }).node;
+  if (!targetNode) {
+    return;
+  }
+
+  if (semver.gt(targetNode, minEnginesVersion)) {
+    throw new Error(
+      `"engines.node" in "${packageJson.name}" package.json allows Node.js ${minEnginesVersion.version}, but the "node" browserslist environment compiles for Node.js ${targetNode} and up. Raise "engines.node" to at least ${targetNode}, or lower the "node" browserslist target.`,
+    );
+  }
+}
+
 /**
  * Marks the start and end of a function execution for performance measurement.
  * Uses the Performance API to create marks and measure the duration.

package/src/utils/credentials.mjs

@@ -23,11 +23,12 @@ const accessedCredentials = new Map();
 
 /**
  * @param {string} key
- * @returns {Promise<string | undefined>}
+ * @returns {Promise<string | null>}
  */
 export async function getPassword(key) {
-  if (accessedCredentials.has(key)) {
-    return accessedCredentials.get(key);
+  const cached = accessedCredentials.get(key);
+  if (cached) {
+    return cached;
   }
   let credential = credentials.get(key);
   if (!credential) {

package/src/utils/extractErrorCodes.mjs

@@ -99,9 +99,7 @@ export default async function extractErrorCodes(args) {
   const packages = basePackages.filter(
     (pkg) =>
       // Ignore obvious packages that do not have user-facing errors
-      !pkg.name.startsWith('@mui/internal-') &&
-      !pkg.name.startsWith('@mui-internal/') &&
-      !skipPackages.includes(pkg.name),
+      !pkg.name.startsWith('@mui/internal-') && !skipPackages.includes(pkg.name),
   );
   const files = await Promise.all(packages.map((pkg) => getFilesForPackage(pkg)));
   packages.forEach((pkg, index) => {

package/src/utils/git.mjs

@@ -9,68 +9,63 @@ import gitUrlParse from 'git-url-parse';
  */
 
 /**
- * Get current repository info from git remote
+ * The repository a remote URL points at, if it is a GitHub repository under `mui`.
+ * @param {string} url
+ * @returns {{ owner: string, repo: string } | null}
+ */
+function muiRepositoryOf(url) {
+  try {
+    const parsed = gitUrlParse(url);
+    return parsed.source === 'github.com' && parsed.owner === 'mui'
+      ? { owner: parsed.owner, repo: parsed.name }
+      : null;
+  } catch {
+    // Not a URL git-url-parse understands, such as a local path: not a mui repository either.
+    return null;
+  }
+}
+
+/**
+ * The canonical repository's remote, as opposed to a fork's: `upstream`, else `origin`, each only if
+ * it points at a mui repository. Reads the configured URLs, which `insteadOf` does not rewrite.
  * @param {string} [cwd=process.cwd()]
- * @returns {Promise<RepoInfo>} Repository owner and name
+ * @returns {Promise<RepoInfo>}
  */
 export async function getRepositoryInfo(cwd = process.cwd()) {
-  /**
-   * @type {Record<string, string>}
-   */
-  const cause = {};
-  const { stdout } = await $({ cwd })`git remote -v`;
-  const lines = stdout.trim().split('\n');
-  /**
-   * @type {Set<string>}
-   */
-  const repoRemotes = new Set();
-  /**
-   * @type {Map<string, { owner: string, repo: string }>}
-   */
-  const validRemotes = new Map();
-
-  for (const line of lines) {
-    // Match pattern: "remoteName url (fetch|push)"
-    const [remoteName, url, type] = line.trim().split(/\s+/, 3);
-    repoRemotes.add(remoteName);
-    if (type === '(fetch)') {
-      try {
-        const parsed = gitUrlParse(url);
-        if (parsed.source !== 'github.com' || parsed.owner !== 'mui') {
-          cause[remoteName] = `Remote is not a GitHub repository under 'mui' organization: ${url}`;
-          continue;
-        }
-        if (!validRemotes.has(remoteName)) {
-          validRemotes.set(remoteName, { owner: parsed.owner, repo: parsed.name });
-        }
-      } catch (error) {
-        cause[remoteName] = `Failed to parse URL for remote ${remoteName}: ${url}`;
-      }
-    } else if (type !== '(push)') {
-      throw new Error(`Unexpected line format for "git remote -v": "${line}"`);
-    }
+  // Exits 1 when neither remote is configured; the error below reports that.
+  const { stdout } = await $({
+    cwd,
+    reject: false,
+  })`git config --get-regexp ${'^remote\\.(upstream|origin)\\.url$'}`;
+  /** @type {Map<string, string>} */
+  const urls = new Map();
+  for (const line of stdout.split('\n').filter(Boolean)) {
+    const [key, url] = line.split(' ', 2);
+    urls.set(key.slice('remote.'.length, -'.url'.length), url);
   }
 
-  const preferredOrder = ['upstream', 'origin', ...validRemotes.keys()];
-  for (const name of preferredOrder) {
-    const match = validRemotes.get(name);
-    if (match) {
-      return { ...match, remoteName: name };
+  for (const remoteName of ['upstream', 'origin']) {
+    const url = urls.get(remoteName);
+    const repository = url ? muiRepositoryOf(url) : null;
+    if (repository) {
+      return { ...repository, remoteName };
     }
   }
 
+  const found = [...urls].map(([name, url]) => `${name}: ${url}`).join(', ') || 'none';
   throw new Error(
-    `Failed to find correct remote(s) in : ${Array.from(repoRemotes.keys()).join(', ')}`,
-    { cause },
+    `No canonical remote: neither \`upstream\` nor \`origin\` points at a mui repository (${found}). ` +
+      'Add an `upstream` remote for it, or name the remote explicitly where the command allows it.',
   );
 }
 
 /**
  * Get current git SHA
+ * @param {string} [cwd=process.cwd()]
  * @returns {Promise<string>} Current git commit SHA
  */
-export async function getCurrentGitSha() {
-  const result = await $`git rev-parse HEAD`;
+export async function getCurrentGitSha(cwd = process.cwd()) {
+  const result = await $({ cwd })`git rev-parse HEAD`;
   return result.stdout.trim();
 }
 
@@ -84,3 +79,69 @@ export async function remoteGitTagExists(tagName, cwd = process.cwd()) {
   const { stdout } = await $({ cwd })`git ls-remote --tags origin refs/tags/${tagName}`;
   return stdout.trim().length > 0;
 }
+
+/**
+ * The default branch of `remote`, as the remote itself reports it.
+ * @param {string} remote
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+async function getDefaultBranchOf(remote, cwd) {
+  const { stdout } = await $({ cwd })`git ls-remote --symref ${remote} HEAD`;
+  const match = /^ref: refs\/heads\/(\S+)\tHEAD$/m.exec(stdout);
+  if (!match) {
+    throw new Error(`Remote "${remote}" does not report a default branch.`);
+  }
+  return match[1];
+}
+
+/**
+ * The commit HEAD should be compared against: where it forked from the base branch, or its parent
+ * when HEAD is already on the base branch.
+ * @param {Object} [options]
+ * @param {string} [options.cwd]
+ * @param {string} [options.remote] - Defaults to the canonical remote.
+ * @param {string} [options.baseBranch] - Defaults to the remote's default branch.
+ * @returns {Promise<string>}
+ */
+export async function resolveBaseline(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const remote = options.remote ?? (await getRepositoryInfo(cwd)).remoteName;
+  const baseBranch = options.baseBranch ?? (await getDefaultBranchOf(remote, cwd));
+
+  await $({ cwd })`git fetch --no-tags ${remote} ${baseBranch}`;
+  const [forkPoint, head] = await Promise.all([
+    $({ cwd })`git merge-base HEAD FETCH_HEAD`.then((result) => result.stdout.trim()),
+    getCurrentGitSha(cwd),
+  ]);
+  if (forkPoint !== head) {
+    return forkPoint;
+  }
+
+  const parent = await $({ cwd, reject: false })`git rev-parse --verify HEAD~1`;
+  if (parent.exitCode !== 0) {
+    throw new Error(
+      'HEAD has no parent commit to compare against. A shallow clone is the usual cause.',
+    );
+  }
+  return parent.stdout.trim();
+}
+
+/**
+ * The most recent version tag reachable from HEAD — where a changelog's range starts.
+ * @param {Object} opts
+ * @param {string} opts.cwd
+ * @param {boolean} [opts.fetchAll=true] Whether to fetch all tags from all remotes before finding the latest tag.
+ * @returns {Promise<string>}
+ */
+export async function findLatestTaggedVersion(opts) {
+  const $$ = $({ cwd: opts.cwd });
+  const fetchAll = opts.fetchAll ?? true;
+  if (fetchAll) {
+    // --force to update any existing tags that may have changed to avoid the clobering error.
+    const { remoteName } = await getRepositoryInfo(opts.cwd);
+    await $$`git fetch --tags --force ${remoteName}`;
+  }
+  const { stdout } = await $$`git describe --tags --abbrev=0 --match ${'v*'}`; // only include "version-tags"
+  return stdout.trim();
+}

package/src/utils/github.mjs

@@ -261,3 +261,30 @@ export async function endToEndGhAuthGetToken({ log = false } = {}) {
 export async function clearGitHubAuth() {
   await credentials.deleteKey(GITHUB_APP_CREDENTIAL_KEY);
 }
+
+/**
+ * Returns when a rate-limited request may be retried, or `null` for other errors.
+ * https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api#exceeding-the-rate-limit
+ *
+ * @param {unknown} error
+ * @returns {Date | null}
+ */
+export function getRateLimitRetryTime(error) {
+  const { status, response, message } = /** @type {any} */ (error) ?? {};
+  if (status !== 403 && status !== 429) {
+    return null;
+  }
+  const headers = response?.headers ?? {};
+  const now = Date.now();
+  let retryTime;
+  if (headers['retry-after']) {
+    retryTime = now + Number(headers['retry-after']) * 1000;
+  } else if (headers['x-ratelimit-remaining'] === '0' && headers['x-ratelimit-reset']) {
+    retryTime = Number(headers['x-ratelimit-reset']) * 1000;
+  } else if (/rate limit/i.test(message ?? '')) {
+    retryTime = now;
+  } else {
+    return null;
+  }
+  return new Date(Math.max(retryTime, now + 60_000));
+}

package/src/utils/pnpm.mjs

@@ -12,6 +12,9 @@ import { parseDocument, isMap } from 'yaml';
 /** Canonical npm registry URL, in the form `getPublishRegistry` returns. */
 const NPMJS_REGISTRY = 'https://registry.npmjs.org/';
 
+/** Version that `publish-new-package` publishes to reserve the name of a new package. */
+export const PLACEHOLDER_VERSION = '0.0.1';
+
 /**
  * @typedef {Object} PrivatePackage
  * @property {string} [name] - Package name
@@ -227,6 +230,112 @@ export async function getPackagesNeedingManualPublish(packages) {
   return packages.filter((_pkg, index) => results[index]);
 }
 
+/**
+ * Why publishing `version` with `tag` would move the dist-tag to the wrong release line.
+ *
+ * @param {string} tag - Dist-tag to publish with
+ * @param {string} version - Version to publish
+ * @param {string} current - Version that the dist-tag points to on the registry
+ * @returns {string | null} The reason, or null when the publish is safe
+ */
+function getDistTagConflict(tag, version, current) {
+  if (semver.lt(version, current)) {
+    return `"${tag}" can only move to a newer version, but ${version} is lower than the current ${current}`;
+  }
+  // A tag that already points to a prerelease can move to the next one, for packages still in beta.
+  if (
+    (tag === 'latest' || tag.startsWith('latest-')) &&
+    semver.prerelease(version) &&
+    !semver.prerelease(current)
+  ) {
+    return `"${tag}" cannot point to a prerelease (${version})`;
+  }
+  if (tag.startsWith('latest-') && semver.major(version) !== semver.major(current)) {
+    return `"${tag}" cannot cross a major (${current} to ${version})`;
+  }
+  return null;
+}
+
+/**
+ * @typedef {Object} RegistryPackage
+ * @property {Record<string, string>} distTags - Dist-tags of the package
+ * @property {string[]} versions - Published versions of the package
+ */
+
+/**
+ * Read the dist-tags and the published versions of each package with `pnpm view`, so
+ * the lookup uses the same registry configuration and credentials as `pnpm publish`.
+ *
+ * @param {PublicPackage[]} packages - Packages to read
+ * @returns {Promise<Map<string, RegistryPackage | null>>} By package name, null for a package that is not on the registry
+ */
+export async function getRegistryPackages(packages) {
+  const entries = await Promise.all(
+    packages.map(async (pkg) => {
+      const registry = await getPublishRegistry(pkg.path);
+      const { exitCode, stdout, stderr } = await $({
+        cwd: pkg.path,
+        reject: false,
+        // pnpm resolves its own `packageManager` version from `--registry`, which may not serve it.
+        env: { PNPM_CONFIG_PM_ON_FAIL: 'ignore' },
+      })`pnpm view ${pkg.name} dist-tags versions --json --registry ${registry}`;
+      let info;
+      try {
+        info = JSON.parse(stdout || '{}');
+      } catch {
+        info = {};
+      }
+      if (exitCode !== 0) {
+        if (info.error?.code === 'ERR_PNPM_FETCH_404') {
+          return /** @type {const} */ ([pkg.name, null]);
+        }
+        throw new Error(
+          `Failed to read the dist-tags of ${pkg.name} from ${registry}: ${info.error?.message ?? stderr}`,
+        );
+      }
+      /** @type {RegistryPackage} */
+      const registryPackage = {
+        distTags: info['dist-tags'] ?? {},
+        versions: [info.versions ?? []].flat(),
+      };
+      return /** @type {const} */ ([pkg.name, registryPackage]);
+    }),
+  );
+  return new Map(entries);
+}
+
+/**
+ * @typedef {Object} DistTagConflict
+ * @property {PublicPackage} pkg - Package to publish
+ * @property {string} reason - Why the dist-tag would move to the wrong release line
+ */
+
+/**
+ * Find the packages whose publish with `tag` would move the dist-tag to the wrong release line.
+ *
+ * @param {PublicPackage[]} packages - Packages to publish
+ * @param {string} tag - Dist-tag to publish with
+ * @param {Map<string, RegistryPackage | null>} registryPackages - Registry data from {@link getRegistryPackages}
+ * @returns {DistTagConflict[]}
+ */
+export function getDistTagConflicts(packages, tag, registryPackages) {
+  return packages.flatMap((pkg) => {
+    const registryPackage = registryPackages.get(pkg.name);
+    // A package that is not on the registry yet has no dist-tags to protect. pnpm skips versions
+    // that are already published, such as unchanged packages on a legacy branch.
+    if (!registryPackage || registryPackage.versions.includes(pkg.version)) {
+      return [];
+    }
+    const current = semver.valid(registryPackage.distTags[tag]);
+    // npm points `latest` at the first version, which is the placeholder for a new package.
+    if (!current || current === PLACEHOLDER_VERSION) {
+      return [];
+    }
+    const reason = getDistTagConflict(tag, pkg.version, current);
+    return reason ? [{ pkg, reason }] : [];
+  });
+}
+
 /**
  * Get package version info from registry.
  *

package/vale/styles/MUI/GoogleLatin.yml

@@ -6,6 +6,9 @@ level: error
 nonword: true
 action:
   name: replace
+# Wider than upstream Google.Latin: also catches e.g/eg./i.e/ie. and any trailing
+# punctuation, so no separate rule asks for "e.g." (which this one forbids).
+# The lookbehind skips matches after a dot or inside a word (example.eg).
 swap:
-  '\b(?:eg|e\.g\.)(?=[\s,;])': for example
-  '\b(?:ie|i\.e\.)(?=[\s,;])': that is
+  '(?<![\w.])e\.?g\.?(?=[^\w.]|$)': for example
+  '(?<![\w.])i\.?e\.?(?=[^\w.]|$)': that is

package/vale/styles/MUI/CorrectRererenceCased.yml

@@ -1,14 +0,0 @@
-# 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.