@mui/internal-code-infra 0.0.4-canary.10 → 0.0.4-canary.100

package/src/cli/cmdBuild.mjs

@@ -10,6 +10,7 @@ import * as semver from 'semver';
 import {
   createPackageBin,
   createPackageExports,
+  createPackageImports,
   getOutExtension,
   mapConcurrently,
   validatePkgJson,
@@ -30,7 +31,8 @@ import {
  * @property {string[]} [copy] - Files/Directories to be copied. Can be a glob pattern.
  * @property {boolean} [enableReactCompiler] - Whether to use the React compiler.
  * @property {boolean} [tsgo] - Whether to build types using typescript native (tsgo).
- * @property {boolean} [flat] - Builds the package in a flat structure without subdirectories for each module type.
+ * @property {boolean} [flat] - Deprecated no-op; flat builds are always used.
+ * @property {boolean} expand - Whether to enumerate glob patterns in exports/imports into concrete entries.
  */
 
 const validBundles = [
@@ -45,13 +47,12 @@ const validBundles = [
  * @param {string} options.name - The name of the package.
  * @param {string} options.version - The version of the package.
  * @param {string} options.license - The license of the package.
- * @param {boolean} options.isFlat - Whether the build is flat structure.
  * @param {'module' | 'commonjs'} options.packageType - The package.json type field.
  * @param {import('../utils/build.mjs').BundleType} options.bundle
  * @param {string} options.outputDir
  */
-async function addLicense({ name, version, license, bundle, outputDir, isFlat, packageType }) {
-  const outExtension = getOutExtension(bundle, { isFlat, packageType });
+async function addLicense({ name, version, license, bundle, outputDir, packageType }) {
+  const outExtension = getOutExtension(bundle, { packageType });
   const file = path.join(outputDir, `index${outExtension}`);
   if (
     !(await fs.stat(file).then(
@@ -80,11 +81,11 @@ ${content}`,
 /**
  * @param {Object} param0
  * @param {import('./packageJson').PackageJson} param0.packageJson - The package.json content.
- * @param {{type: import('../utils/build.mjs').BundleType; dir: string}[]} param0.bundles
+ * @param {import('../utils/build.mjs').BundleType[]} param0.bundles
  * @param {string} param0.outputDir
  * @param {string} param0.cwd
  * @param {boolean} param0.addTypes - Whether to add type declarations for the package.
- * @param {boolean} param0.isFlat - Whether the build is flat structure.
+ * @param {boolean} [param0.expand] - Whether to enumerate glob patterns into concrete entries.
  * @param {'module' | 'commonjs'} param0.packageType - The package.json type field.
  */
 async function writePackageJson({
@@ -93,37 +94,48 @@ async function writePackageJson({
   outputDir,
   cwd,
   addTypes = false,
-  isFlat = false,
+  expand = true,
   packageType,
 }) {
   delete packageJson.scripts;
   delete packageJson.publishConfig?.directory;
   delete packageJson.devDependencies;
-  delete packageJson.imports;
 
   const resolvedPackageType = packageType || packageJson.type || 'commonjs';
   packageJson.type = resolvedPackageType;
 
   const originalExports = packageJson.exports;
   delete packageJson.exports;
+  const originalImports = packageJson.imports;
+  delete packageJson.imports;
   const originalBin = packageJson.bin;
   delete packageJson.bin;
 
-  const {
-    exports: packageExports,
-    main,
-    types,
-  } = await createPackageExports({
-    exports: originalExports,
-    bundles,
-    outputDir,
-    cwd,
-    addTypes,
-    isFlat,
-    packageType: resolvedPackageType,
-  });
+  const [{ exports: packageExports, main, types }, packageImports] = await Promise.all([
+    createPackageExports(originalExports, {
+      bundles,
+      outputDir,
+      cwd,
+      addTypes,
+      expand,
+      packageType: resolvedPackageType,
+    }),
+    originalImports
+      ? createPackageImports(originalImports, {
+          bundles,
+          cwd,
+          outputDir,
+          addTypes,
+          expand,
+          packageType: resolvedPackageType,
+        })
+      : Promise.resolve(undefined),
+  ]);
 
   packageJson.exports = packageExports;
+  if (packageImports) {
+    packageJson.imports = packageImports;
+  }
   if (main) {
     packageJson.main = main;
   }
@@ -131,11 +143,9 @@ async function writePackageJson({
     packageJson.types = types;
   }
 
-  const bin = await createPackageBin({
-    bin: originalBin,
+  const bin = await createPackageBin(originalBin, {
     bundles,
     cwd,
-    isFlat,
     packageType: resolvedPackageType,
   });
   if (bin) {
@@ -225,16 +235,23 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       })
       .option('flat', {
         type: 'boolean',
-        default: process.env.MUI_BUILD_FLAT === '1',
+        deprecated:
+          'Flat builds are now always used; this flag is a no-op and will be removed in a future release.',
+        default: true,
+        description:
+          '@deprecated Flat builds are always used now. The package is always built in a flat structure without subdirectories for each module type.',
+      })
+      .option('expand', {
+        type: 'boolean',
+        default: true,
         description:
-          'Builds the package in a flat structure without subdirectories for each module type.',
+          'Enumerate glob patterns in the package.json "exports"/"imports" into concrete entries. Use --no-expand to keep them as Node runtime subpath patterns.',
       });
   },
   async handler(args) {
     const {
       bundle: bundles,
       hasLargeFiles,
-      skipBundlePackageJson,
       verbose = false,
       ignore: extraIgnores,
       buildTypes,
@@ -255,9 +272,6 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     const packageType = packageJson.type === 'module' ? 'module' : 'commonjs';
 
     console.log(`Selected output directory: "${buildDirBase}"`);
-    if (args.flat) {
-      console.log('Building package in flat structure.');
-    }
 
     await fs.rm(buildDir, { recursive: true, force: true });
 
@@ -282,15 +296,6 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     }
 
     const { build: babelBuild, cjsCopy } = await import('../utils/babel.mjs');
-    const relativeOutDirs = !args.flat
-      ? {
-          cjs: '.',
-          esm: 'esm',
-        }
-      : {
-          cjs: '.',
-          esm: '.',
-        };
     const sourceDir = path.join(cwd, 'src');
     const reactVersion =
       semver.minVersion(packageJson.peerDependencies?.react || '')?.version ?? 'latest';
@@ -306,13 +311,10 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     await Promise.all(
       bundles.map(async (bundle) => {
         const outExtension = getOutExtension(bundle, {
-          isFlat: !!args.flat,
           isType: false,
           packageType,
         });
-        const relativeOutDir = relativeOutDirs[bundle];
-        const outputDir = path.join(buildDir, relativeOutDir);
-        await fs.mkdir(outputDir, { recursive: true });
+        await fs.mkdir(buildDir, { recursive: true });
 
         const promises = [];
 
@@ -320,7 +322,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
           babelBuild({
             cwd,
             sourceDir,
-            outDir: outputDir,
+            outDir: buildDir,
             babelRuntimeVersion,
             hasLargeFiles,
             bundle,
@@ -340,61 +342,28 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
           }),
         );
 
-        if (buildDir !== outputDir && !skipBundlePackageJson && !args.flat) {
-          // @TODO - Not needed if the output extension is .mjs. Remove this before PR merge.
-          promises.push(
-            fs.writeFile(
-              path.join(outputDir, 'package.json'),
-              JSON.stringify({
-                type: bundle === 'esm' ? 'module' : 'commonjs',
-                sideEffects: packageJson.sideEffects ?? false,
-              }),
-            ),
-          );
-        }
-
-        if (!args.flat) {
-          // cjs for reexporting from commons only modules.
-          // @NOTE: If we need to rely more on this we can think about setting up
-          // a separate commonjs => commonjs build for .cjs files to .cjs
-          // `--extensions-.cjs --out-file-extension .cjs`
-          promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
-        }
-
         await Promise.all(promises);
         await addLicense({
           bundle,
           license: packageJson.license,
           name: packageJson.name,
           version: packageJson.version,
-          outputDir,
-          isFlat: !!args.flat,
+          outputDir: buildDir,
           packageType,
         });
       }),
     );
 
-    if (args.flat) {
-      await cjsCopy({ from: sourceDir, to: buildDir });
-    }
+    await cjsCopy({ from: sourceDir, to: buildDir });
     // js build end
 
     if (buildTypes) {
       const tsMod = await import('../utils/typescript.mjs');
-      /**
-       * @type {{type: import('../utils/build.mjs').BundleType, dir: string}[]};
-       */
-      const bundleMap = bundles.map((type) => ({
-        type,
-        dir: relativeOutDirs[type],
-      }));
-
       await tsMod.createTypes({
-        bundles: bundleMap,
+        bundles,
         srcDir: sourceDir,
         cwd,
         skipTsc,
-        isFlat: !!args.flat,
         buildDir,
         useTsgo,
         packageType,
@@ -409,13 +378,10 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     await writePackageJson({
       cwd,
       packageJson,
-      bundles: bundles.map((type) => ({
-        type,
-        dir: relativeOutDirs[type],
-      })),
+      bundles,
       outputDir: buildDir,
       addTypes: buildTypes,
-      isFlat: !!args.flat,
+      expand: args.expand,
       packageType,
     });
 

package/src/cli/cmdListWorkspaces.mjs

@@ -61,7 +61,13 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         console.log(pkg.path);
       });
     } else if (output === 'publish-dir') {
-      // TODO: Remove this option once https://github.com/stackblitz-labs/pkg.pr.new/issues/389 is resolved
+      // Works around https://github.com/stackblitz-labs/pkg.pr.new/issues/389: pkg-pr-new rewrites
+      // workspace:* deps to its URLs in the source package.json, but `pnpm pack` honors
+      // publishConfig.directory and packs the build package.json, whose workspace:* deps are left to
+      // resolve to plain versions. Pointing pkg-pr-new at the build dir makes both act on the same file.
+      // Note: #389 was closed by pkg-pr-new#499, but that only fixed the tarball location, not the dep
+      // resolution — verified still broken on 0.0.78. Do not remove until the packed deps are URLs
+      // without this. Removing it prematurely regressed publishing once (see mui-public#1354).
       // Print publish directories (package.json publishConfig.directory or package path)
       const publishDirs = await Promise.all(
         packages.map(async (pkg) => {

package/src/cli/cmdNetlifyIgnore.mjs

@@ -6,6 +6,7 @@
  * @typedef {Object} Args
  * @property {string[]} workspaces - List of workspace names to process
  * @property {boolean} [check] - Check mode - error if the generated content differs from current
+ * @property {string} [baseBranch] - Branch to compare PRs against (default: master)
  */
 
 import * as fs from 'node:fs/promises';
@@ -15,16 +16,29 @@ import { toPosixPath } from '../utils/path.mjs';
 import { getTransitiveDependencies, getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
- * Generate the ignore command string for netlify.toml
+ * Generate the ignore command string for netlify.toml.
+ *
+ * Production and branch deploys (every Netlify $CONTEXT other than
+ * "deploy-preview") always build, so downstream plugins (e.g. e2e triggers)
+ * run on every deploy and catch regressions in external dependencies even
+ * when the commit doesn't touch the watched paths.
+ *
+ * Only deploy-previews (PR previews) are eligible to be skipped: they diff
+ * against the merge-base with origin/<baseBranch>. This way a PR rebase whose
+ * head commit doesn't touch the watched paths still rebuilds when the PR as a
+ * whole introduces changes to them — otherwise downstream plugins silently
+ * never run.
+ *
  * @param {string[]} paths - Array of paths to include in the ignore command
  * @param {string} packagePath - Absolute path to the package directory
  * @param {string} workspaceRoot - Absolute path to the workspace root
+ * @param {string} baseBranch - Branch to compare PRs against
  * @returns {string} The ignore command string
  */
-function generateIgnoreCommand(paths, packagePath, workspaceRoot) {
+function generateIgnoreCommand(paths, packagePath, workspaceRoot, baseBranch) {
   const relFromBase = `${toPosixPath(path.relative(packagePath, workspaceRoot))}/`;
   const pathsStr = paths.join(' ');
-  return `  ignore = "cd ${relFromBase} && git diff --quiet $CACHED_COMMIT_REF $COMMIT_REF ${pathsStr}"`;
+  return `  ignore = """cd ${relFromBase} && [ "$CONTEXT" = "deploy-preview" ] && git fetch origin ${baseBranch} --depth=500 -q && git diff --quiet FETCH_HEAD...$COMMIT_REF -- ${pathsStr}"""`;
 }
 
 /**
@@ -94,6 +108,12 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         default: false,
         describe: 'Check if the netlify.toml needs updating without modifying it',
       })
+      .option('base-branch', {
+        type: 'string',
+        default: 'master',
+        describe:
+          "Branch to compare PRs against (the site's production branch on Netlify). Production and branch deploys always rebuild regardless of this value.",
+      })
       .example('$0 netlify-ignore @mui/internal-docs-infra', 'Update netlify.toml for a workspace')
       .example(
         '$0 netlify-ignore @mui/internal-docs-infra @mui/internal-code-infra',
@@ -105,7 +125,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       );
   },
   handler: async (argv) => {
-    const { workspaces, check = false } = argv;
+    const { workspaces, check = false, baseBranch = 'master' } = argv;
 
     // Get the workspace root
     const workspaceRoot = await findWorkspaceDir(process.cwd());
@@ -157,7 +177,12 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         const allPaths = [...relativePaths, 'pnpm-lock.yaml'];
 
         // Generate the ignore command for this workspace
-        const newIgnoreCommand = generateIgnoreCommand(allPaths, workspacePath, workspaceRoot);
+        const newIgnoreCommand = generateIgnoreCommand(
+          allPaths,
+          workspacePath,
+          workspaceRoot,
+          baseBranch,
+        );
 
         // Update or check the netlify.toml file
         await updateNetlifyToml(tomlPath, newIgnoreCommand, check);

package/src/cli/cmdPublish.mjs

@@ -5,6 +5,7 @@
 /**
  * @typedef {import('../utils/pnpm.mjs').PublicPackage} PublicPackage
  * @typedef {import('../utils/pnpm.mjs').PublishOptions} PublishOptions
+ * @typedef {import('../utils/pnpm.mjs').PublishSummaryEntry} PublishSummaryEntry
  */
 
 import select from '@inquirer/select';
@@ -18,11 +19,13 @@ import * as semver from 'semver';
 
 import { persistentAuthStrategy } from '../utils/github.mjs';
 import {
+  getPackagesNeedingManualPublish,
+  getReleaseVersion,
   getWorkspacePackages,
   publishPackages,
   validatePublishDependencies,
 } from '../utils/pnpm.mjs';
-import { getCurrentGitSha, getRepositoryInfo } from '../utils/git.mjs';
+import { getCurrentGitSha, getRepositoryInfo, remoteGitTagExists } from '../utils/git.mjs';
 
 const isCI = envCI().isCi;
 
@@ -40,16 +43,6 @@ function getOctokit() {
  * @property {string[]} [filter] Same as filtering packages with --filter in pnpm. Only publish packages matching the filter. See https://pnpm.io/filtering.
  */
 
-/**
- * Get the version to release from the root package.json
- * @returns {Promise<string | null>} Version string
- */
-async function getReleaseVersion() {
-  const result = await $`pnpm pkg get version`;
-  const version = JSON.parse(result.stdout.trim());
-  return semver.valid(version);
-}
-
 /**
  * Parse changelog to extract content for a specific version
  * @param {string} changelogPath - Path to CHANGELOG.md
@@ -139,8 +132,19 @@ async function checkGitHubReleaseExists(owner, repo, version) {
  */
 async function createGitTag(version, dryRun = false) {
   const tagName = `v${version}`;
+  // The CI smoke-test runs with a read-only token that can't push. It sets this
+  // so we tolerate the push failure explicitly, instead of assuming any dry-run
+  // permission error is expected.
+  const isPublishTest = process.env.IS_PUBLISH_TEST === 'true';
 
   try {
+    // Skip if the tag already exists locally. Tag creation is local and fails if it exists.
+    const { stdout: existingTag } = await $`git tag -l ${tagName}`;
+    if (existingTag.trim()) {
+      console.log(`🏷️  Git tag ${tagName} already exists, skipping`);
+      return;
+    }
+
     await $({
       env: {
         ...process.env,
@@ -148,10 +152,28 @@ async function createGitTag(version, dryRun = false) {
         GIT_COMMITTER_EMAIL: 'code-infra@mui.com',
       },
     })`git tag -a ${tagName} -m ${`Version ${version}`}`;
-    const pushArgs = dryRun ? ['--dry-run'] : [];
-    await $({ stdio: 'inherit' })`git push origin ${tagName} ${pushArgs}`;
 
-    console.log(`🏷️  Created and pushed git tag ${tagName}${dryRun ? ' (dry-run)' : ''}`);
+    if (dryRun) {
+      // `git push --dry-run` still authenticates and needs push access. When the token
+      // can push, validate it for real; when it can't, only tolerate the failure if this
+      // is an explicit publish smoke-test and the error is a genuine permission denial.
+      try {
+        // Don't inherit stdio so stderr is captured and matchable below.
+        await $`git push origin ${tagName} --dry-run`;
+        console.log(`🏷️  Created git tag ${tagName} (dry-run)`);
+      } catch (/** @type {any} */ pushError) {
+        const message = pushError.stderr || pushError.message || '';
+        if (isPublishTest && /permission|403|denied/i.test(message)) {
+          console.log(`🏷️  Created git tag ${tagName} (dry-run, no push permission, skipped push)`);
+          return;
+        }
+        throw pushError;
+      }
+      return;
+    }
+    await $({ stdio: 'inherit' })`git push origin ${tagName}`;
+
+    console.log(`🏷️  Created and pushed git tag ${tagName}`);
   } catch (/** @type {any} */ error) {
     throw new Error(`Failed to create git tag: ${error.message}`);
   }
@@ -194,18 +216,11 @@ async function validateGitHubRelease(version) {
  * Publish packages to npm
  * @param {PublicPackage[]} packages - Packages to publish
  * @param {PublishOptions} options - Publishing options
- * @returns {Promise<void>}
+ * @returns {Promise<PublishSummaryEntry[]>}
  */
 async function publishToNpm(packages, options) {
-  console.log('\n📦 Publishing packages to npm...');
-  console.log(`📋 Found ${packages.length} packages:`);
-  packages.forEach((pkg) => {
-    console.log(`   • ${pkg.name}@${pkg.version}`);
-  });
-
   // Use pnpm's built-in duplicate checking - no need to check versions ourselves
-  await publishPackages(packages, options);
-  console.log('✅ Successfully published to npm');
+  return publishPackages(packages, options);
 }
 
 /**
@@ -301,9 +316,9 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     // Get all packages
     console.log('🔍 Discovering all workspace packages...');
 
-    const allPackages = await getWorkspacePackages({ publicOnly: true, filter });
+    const filteredPackages = await getWorkspacePackages({ publicOnly: true, filter });
 
-    if (allPackages.length === 0) {
+    if (filteredPackages.length === 0) {
       console.log(
         `⚠️  No publishable packages found in workspace${filter.length > 0 ? ` matching filter "${filter.join(', ')}"` : ''}`,
       );
@@ -313,12 +328,17 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     if (filter.length > 0) {
       console.log('🔍 Validating workspace dependencies for filtered packages...');
 
-      const { issues } = await validatePublishDependencies(allPackages);
+      const { issues } = await validatePublishDependencies(filteredPackages);
 
       if (issues.length > 0) {
-        throw new Error('Invalid dependencies structure of packages to be published.', {
-          cause: issues,
-        });
+        throw new Error(
+          `Invalid dependencies structure of packages to be published -
+  ${issues.join('\n  ')}
+`,
+          {
+            cause: issues,
+          },
+        );
       }
 
       console.log('✅ All workspace dependency requirements satisfied');
@@ -338,21 +358,41 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       githubReleaseData = await validateGitHubRelease(version);
     }
 
-    const newPackages = await getWorkspacePackages({ nonPublishedOnly: true });
+    const newPackages = await getPackagesNeedingManualPublish(filteredPackages);
 
     if (newPackages.length > 0) {
+      const newPackageNames = newPackages.map((pkg) => pkg.name).join(', ');
       throw new Error(
-        `The following packages are new and need to be published manually first: ${newPackages.join(
-          ', ',
-        )}. Read more about it here: https://github.com/mui/mui-public/blob/master/packages/code-infra/README.md#adding-and-publishing-new-packages`,
+        `The following packages are new and need to be published to npm manually first: ${newPackageNames}. Read more about it here: https://github.com/mui/mui-public/blob/master/packages/code-infra/README.md#adding-and-publishing-new-packages`,
       );
     }
 
     // Publish to npm (pnpm handles duplicate checking automatically)
     // No git checks, we'll do our own
-    await publishToNpm(allPackages, { dryRun, noGitChecks: true, tag });
+    console.log('\n📦 Publishing packages to npm...');
+    const publishedPackages = await publishToNpm(filteredPackages, {
+      dryRun,
+      noGitChecks: true,
+      tag,
+    });
+
+    if (publishedPackages.length === 0) {
+      console.log('ℹ️  No packages were published (all may already be up to date on npm)');
+      console.log('\n🏁 Nothing to publish, skipping git tag and GitHub release.');
+      return;
+    }
+
+    publishedPackages.forEach((pkg) => {
+      console.log(`✅ Published ${pkg.name}@${pkg.version}`);
+    });
 
-    await createGitTag(version, dryRun);
+    // Tag the root version when it's new. Arbitrary package publishes that don't
+    // bump the root version don't create a new tag, so skip in that case.
+    if (await remoteGitTagExists(`v${version}`)) {
+      console.log(`ℹ️  Git tag v${version} already exists, skipping tag creation.`);
+    } else {
+      await createGitTag(version, dryRun);
+    }
 
     // Create GitHub release or git tag after successful npm publishing
     if (githubRelease && githubReleaseData) {
@@ -380,11 +420,13 @@ const PUBLISH_WORKFLOW_ID = `.github/${WORKFLOW_PATH}`;
  */
 async function triggerLocalGithubPublishWorkflow(opts) {
   console.log(`🔍 Checking if there are new packages to publish in the workspace...`);
-  const newPackages = await getWorkspacePackages({ nonPublishedOnly: true });
+  const newPackages = await getPackagesNeedingManualPublish(
+    await getWorkspacePackages({ publicOnly: true }),
+  );
   if (newPackages.length) {
     console.warn(
       `⚠️  Found new packages that should be published to npm first before triggering a release:
-  * ${newPackages.map((pkg) => pkg.name).join('  * ')}
+${newPackages.map((pkg) => `  * ${pkg.name}`).join('\n')}
 Please run the command "${chalk.bold('pnpm code-infra publish-new-package')}" first to publish and configure npm.`,
     );
     return;