@mui/internal-code-infra 0.0.4-canary.7 → 0.0.4-canary.71

package/src/brokenLinksChecker/index.test.ts

@@ -2,12 +2,21 @@ import path from 'node:path';
 import getPort from 'get-port';
 import { describe, expect, it } from 'vitest';
 
-// eslint-disable-next-line import/extensions
-import { crawl, Issue, Link } from './index.mjs';
-
-type ExpectedIssue = Omit<Partial<Issue>, 'link'> & { link?: Partial<Link> };
-
-function objectMatchingIssue(expectedIssue: ExpectedIssue) {
+import {
+  crawl,
+  // eslint-disable-next-line import/extensions
+} from './index.mjs';
+import type {
+  BrokenLinkIssue,
+  HtmlValidateIssue,
+  Issue,
+  Link,
+  // eslint-disable-next-line import/extensions
+} from './index.mjs';
+
+type ExpectedBrokenLinkIssue = Omit<Partial<BrokenLinkIssue>, 'link'> & { link?: Partial<Link> };
+
+function objectMatchingIssue(expectedIssue: ExpectedBrokenLinkIssue) {
   return expect.objectContaining({
     ...expectedIssue,
     ...(expectedIssue.link ? { link: expect.objectContaining(expectedIssue.link) } : {}),
@@ -15,16 +24,16 @@ function objectMatchingIssue(expectedIssue: ExpectedIssue) {
 }
 
 /**
- * Helper to assert that an issue with matching properties exists in the issues array
+ * Helper to assert that a broken link issue with matching properties exists in the issues array
  */
-function expectIssue(issues: Issue[], expectedIssue: ExpectedIssue) {
+function expectIssue(issues: Issue[], expectedIssue: ExpectedBrokenLinkIssue) {
   expect(issues).toEqual(expect.arrayContaining([objectMatchingIssue(expectedIssue)]));
 }
 
 /**
- * Helper to assert that no issue with matching properties exists in the issues array
+ * Helper to assert that no broken link issue with matching properties exists in the issues array
  */
-function expectNotIssue(issues: Issue[], notExpectedIssue: ExpectedIssue) {
+function expectNotIssue(issues: Issue[], notExpectedIssue: ExpectedBrokenLinkIssue) {
   expect(issues).not.toEqual(expect.arrayContaining([objectMatchingIssue(notExpectedIssue)]));
 }
 
@@ -56,12 +65,30 @@ describe('Broken Links Checker', () => {
         // Test href-only rule (matches from any page) - note: matches the actual href value
         { href: 'broken-relative.html' },
       ],
+      // Exercise the array form with union semantics: every matching entry
+      // contributes to the page's config. The baseline entry (no `path`)
+      // turns off `no-dup-id` everywhere; the path-specific entry turns off
+      // `no-raw-characters` only on /invalid-html.html. Both rules are
+      // silenced on that page because the configs are merged, not replaced.
+      //
+      // This also guards against the path-specific entry clobbering the
+      // baseline: the path entry only names `no-raw-characters`, so it must
+      // not re-introduce the recommended ruleset and re-enable the
+      // `no-dup-id` that the baseline silenced (which /invalid-html.html
+      // violates). If it did, that page would report `no-dup-id` below.
+      htmlValidate: [
+        { config: { rules: { 'no-dup-id': 'off' } } },
+        { path: '/invalid-html.html', config: { rules: { 'no-raw-characters': 'off' } } },
+      ],
     });
 
-    expect(result.links).toHaveLength(66);
-    // Issue count: original 11, minus ignored ones (broken-from-markdown via contentType,
+    expect(result.links).toHaveLength(67);
+    // Broken link issue count: original 11, minus ignored ones (broken-from-markdown via contentType,
     // broken-relative via href-only rule)
-    expect(result.issues).toHaveLength(9);
+    const brokenLinkIssues = result.issues.filter(
+      (issue) => issue.type === 'broken-link' || issue.type === 'broken-target',
+    );
+    expect(brokenLinkIssues).toHaveLength(9);
 
     // Test ignores: these broken links should be ignored (not in issues)
     expectNotIssue(result.issues, {
@@ -257,5 +284,18 @@ describe('Broken Links Checker', () => {
     // Test contentType is stored on pageData
     expect(result.pages.get('/example.md')?.contentType).toBe('text/markdown');
     expect(result.pages.get('/')?.contentType).toBe('text/html');
+
+    // Test htmlValidate union semantics: invalid-html.html has both a duplicate
+    // ID (no-dup-id) and a raw `&` (no-raw-characters). The baseline entry
+    // silences no-dup-id; the path-specific entry silences no-raw-characters.
+    // Under union semantics both apply, so the page reports zero issues — and
+    // the path-specific entry must not clobber the baseline's no-dup-id.
+    const htmlValidateIssues = result.issues.filter(
+      (issue): issue is HtmlValidateIssue => issue.type === 'html-validate',
+    );
+    const invalidHtmlIssues = htmlValidateIssues.filter(
+      (issue) => issue.pageUrl === '/invalid-html.html',
+    );
+    expect(invalidHtmlIssues).toEqual([]);
   }, 30000);
 });

package/src/changelog/categorizeCommits.test.ts

@@ -84,15 +84,15 @@ describe('categorizeCommits', () => {
         labels: {
           ...baseLabelConfig,
           categoryOverrides: {
-            'all components': 'General changes',
+            'scope: all components': 'General changes',
           },
         },
       };
 
       const commits = [
-        createCommit(1, ['component: Button', 'all components']),
+        createCommit(1, ['component: Button', 'scope: all components']),
         createCommit(2, ['component: Checkbox']),
-        createCommit(3, ['component: Button', 'all components']),
+        createCommit(3, ['component: Button', 'scope: all components']),
       ];
 
       const result = categorizeCommits(commits, configWithOverrides);
@@ -229,13 +229,13 @@ describe('categorizeCommits', () => {
         labels: {
           ...baseLabelConfig,
           categoryOverrides: {
-            'all packages': 'General changes',
+            'scope: all components': 'General changes',
           },
         },
       };
 
       const commits = [
-        createCommit(1, ['scope: data grid', 'all packages']),
+        createCommit(1, ['scope: data grid', 'scope: all components']),
         createCommit(2, ['scope: charts']),
       ];
 

package/src/changelog/fetchChangelogs.mjs

@@ -93,8 +93,12 @@ async function fetchCommitsRest({ octokit, repo, lastRelease, release, org = 'mu
   }
 
   const promises = results.map(async (commit) => {
-    const prMatch = commit.commit.message.match(/#(\d+)/);
-    if (prMatch === null) {
+    const matches = [...commit.commit.message.matchAll(/#(\d+)/g)];
+    // The PR number is always the last match.
+    // Sometimes the PR titles include an issue number like this:
+    // [tag] PR title (#00001) (#00002)
+    const prMatch = matches.at(-1);
+    if (!prMatch) {
       return null;
     }
 

package/src/changelog/parseCommitLabels.test.ts

@@ -210,11 +210,11 @@ describe('parseCommitLabels', () => {
 
   describe('category overrides', () => {
     it('should detect category override labels', () => {
-      const commit = createCommit({ labels: ['all components'] });
+      const commit = createCommit({ labels: ['scope: all components'] });
       const config: LabelConfig = {
         ...baseLabelConfig,
         categoryOverrides: {
-          'all components': 'General changes',
+          'scope: all components': 'General changes',
         },
       };
 
@@ -224,11 +224,11 @@ describe('parseCommitLabels', () => {
     });
 
     it('should use the last category override when multiple are present', () => {
-      const commit = createCommit({ labels: ['all components', 'docs'] });
+      const commit = createCommit({ labels: ['scope: all components', 'docs'] });
       const config: LabelConfig = {
         ...baseLabelConfig,
         categoryOverrides: {
-          'all components': 'General changes',
+          'scope: all components': 'General changes',
           docs: 'Documentation',
         },
       };
@@ -243,7 +243,7 @@ describe('parseCommitLabels', () => {
       const config: LabelConfig = {
         ...baseLabelConfig,
         categoryOverrides: {
-          'all components': 'General changes',
+          'scope: all components': 'General changes',
         },
       };
 

package/src/changelog/renderChangelog.mjs

@@ -438,7 +438,7 @@ function renderContributors(contributors, config, lines) {
     const template = getTemplateString(
       config.contributors?.message?.contributors,
       allContributors.length,
-      `${allContributors.length !== 1 ? 'All contributors of this release in alphabetical order' : 'Contributor of this release'} : {{contributors}}`,
+      `${allContributors.length !== 1 ? 'All contributors of this release in alphabetical order' : 'Contributor of this release'}: {{contributors}}`,
     );
     const contributorsMessage = templateString(template, {
       contributors: renderContributorsList(allContributors),

package/src/changelog/types.ts

@@ -233,7 +233,7 @@ export interface IntroConfig {
    * - {{teamCount}}: Number of team members
    * - {{communityCount}}: Number of community contributors
    *
-   * Example: "We'd like to extend a big thank you to the {{contributorCount}} contributors who made this release possible"
+   * Example: "A big thanks to the {{contributorCount}} contributors who made this release possible."
    *
    * Set to `false` or omit to disable the thank you message.
    */

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) => {