@mui/internal-code-infra 0.0.4-canary.8 → 0.0.4-canary.80

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

@@ -6,15 +6,14 @@
  * @typedef {import('../utils/pnpm.mjs').PublicPackage} PublicPackage
  */
 
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import { getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args
  * @property {boolean} [publicOnly] - Whether to filter to only public packages
- * @property {'json'|'path'|'name'|'publish-dir'} [output] - Output format (name, path, or json)
+ * @property {'json'|'path'|'name'} [output] - Output format (name, path, or json)
  * @property {string} [sinceRef] - Git reference to filter changes since
+ * @property {string[]} [filter] - Same as filtering packages with --filter in pnpm. Only include packages matching the filter. See https://pnpm.io/filtering.
  */
 
 export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
@@ -29,21 +28,27 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       })
       .option('output', {
         type: 'string',
-        choices: ['json', 'path', 'name', 'publish-dir'],
+        choices: ['json', 'path', 'name'],
         default: 'path',
         description:
-          'Output format: name (package names), path (package paths), publish-dir (publish directories), or json (full JSON)',
+          'Output format: name (package names), path (package paths), or json (full JSON)',
       })
       .option('since-ref', {
         type: 'string',
         description: 'Filter packages changed since git reference',
+      })
+      .option('filter', {
+        type: 'string',
+        array: true,
+        description:
+          'Same as filtering packages with --filter in pnpm. Only include packages matching the filter. See https://pnpm.io/filtering.',
       });
   },
   handler: async (argv) => {
-    const { publicOnly = false, output = 'name', sinceRef } = argv;
+    const { publicOnly = false, output = 'name', sinceRef, filter = [] } = argv;
 
     // Get packages using our helper function
-    const packages = await getWorkspacePackages({ sinceRef, publicOnly });
+    const packages = await getWorkspacePackages({ sinceRef, publicOnly, filter });
 
     if (output === 'json') {
       // Serialize packages to JSON
@@ -53,26 +58,6 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       packages.forEach((pkg) => {
         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
-      // Print publish directories (package.json publishConfig.directory or package path)
-      const publishDirs = await Promise.all(
-        packages.map(async (pkg) => {
-          const packageJsonPath = path.join(pkg.path, 'package.json');
-          const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
-          const packageJson = JSON.parse(packageJsonContent);
-
-          if (packageJson.publishConfig?.directory) {
-            return path.join(pkg.path, packageJson.publishConfig.directory);
-          }
-
-          return pkg.path;
-        }),
-      );
-
-      publishDirs.forEach((dir) => {
-        console.log(dir);
-      });
     } else if (output === 'name') {
       // Print package names (default)
       packages.forEach((pkg) => {

package/src/cli/cmdNetlifyIgnore.mjs

@@ -6,111 +6,39 @@
  * @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';
 import * as path from 'node:path';
 import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { toPosixPath } from '../utils/path.mjs';
-import { getWorkspacePackages } from '../utils/pnpm.mjs';
+import { getTransitiveDependencies, getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
- * Get all workspace dependencies (direct and transitive) from a package
- * @param {string} packageName - Package name
- * @param {Map<string, string>} workspaceMap - Map of workspace name to path
- * @param {Map<string, Promise<Set<string>>>} cache - Cache of package resolution promises
- * @returns {Promise<Set<string>>} Set of workspace package names (dependencies only, not including the package itself)
- */
-async function getWorkspaceDependenciesRecursive(packageName, workspaceMap, cache) {
-  // Check cache first
-  const cached = cache.get(packageName);
-  if (cached) {
-    return cached;
-  }
-
-  // Create the resolution promise
-  const promise = (async () => {
-    const packagePath = workspaceMap.get(packageName);
-    if (!packagePath) {
-      throw new Error(`Workspace "${packageName}" not found in the repository`);
-    }
-
-    const packageJsonPath = path.join(packagePath, 'package.json');
-    const content = await fs.readFile(packageJsonPath, 'utf8');
-    const packageJson = JSON.parse(content);
-
-    // Collect all dependency names
-    /** @type {Set<string>} */
-    const allDeps = new Set();
-    if (packageJson.dependencies) {
-      Object.keys(packageJson.dependencies).forEach((dep) => allDeps.add(dep));
-    }
-    if (packageJson.devDependencies) {
-      Object.keys(packageJson.devDependencies).forEach((dep) => allDeps.add(dep));
-    }
-    if (packageJson.peerDependencies) {
-      Object.keys(packageJson.peerDependencies).forEach((dep) => allDeps.add(dep));
-    }
-
-    // Filter to only workspace dependencies
-    const workspaceDeps = Array.from(allDeps).filter((dep) => workspaceMap.has(dep));
-
-    // Recursively process workspace dependencies in parallel
-    const recursiveResults = await Promise.all(
-      workspaceDeps.map(async (dep) => {
-        return getWorkspaceDependenciesRecursive(dep, workspaceMap, cache);
-      }),
-    );
-
-    // Merge all results using flatMap
-    return new Set(recursiveResults.flatMap((result) => Array.from(result)).concat(workspaceDeps));
-  })();
-
-  // Store in cache before returning
-  cache.set(packageName, promise);
-
-  return promise;
-}
-
-/**
- * Get transitive workspace dependencies for a list of workspace names
- * @param {string[]} workspaceNames - Array of workspace names
- * @param {Map<string, string>} workspaceMap - Map of workspace name to path
- * @returns {Promise<Set<string>>} Set of workspace package names (including requested packages and all their dependencies)
- */
-async function getTransitiveDependencies(workspaceNames, workspaceMap) {
-  // Shared cache for all workspace dependency resolution
-  const cache = new Map();
-
-  // Validate all workspace names exist
-  for (const workspaceName of workspaceNames) {
-    if (!workspaceMap.has(workspaceName)) {
-      throw new Error(`Workspace "${workspaceName}" not found in the repository`);
-    }
-  }
-
-  // Process each requested workspace in parallel
-  const workspaceResults = await Promise.all(
-    workspaceNames.map((workspaceName) =>
-      getWorkspaceDependenciesRecursive(workspaceName, workspaceMap, cache),
-    ),
-  );
-
-  // Merge all results using flatMap and add the original package names
-  return new Set(workspaceNames.concat(workspaceResults.flatMap((result) => Array.from(result))));
-}
-
-/**
- * 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}"""`;
 }
 
 /**
@@ -180,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',
@@ -191,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());
@@ -220,7 +154,9 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         console.log(`Processing ${workspaceName}...`);
 
         // Get transitive dependencies for this specific workspace
-        const dependencyNames = await getTransitiveDependencies([workspaceName], workspaceMap);
+        const dependencyNames = await getTransitiveDependencies([workspaceName], {
+          workspacePathByName: workspaceMap,
+        });
 
         // Convert package names to relative paths (normalize to POSIX separators for git)
         const relativePaths = Array.from(dependencyNames)
@@ -241,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);