@mui/internal-code-infra 0.0.4-canary.66 → 0.0.4-canary.68

package/src/utils/typescript.mjs

@@ -111,30 +111,21 @@ export async function copyDeclarations(sourceDirectory, destinationDirectory, op
  * @param {Object} param0
  * @param {string} param0.inputDir
  * @param {string} param0.buildDir
- * @param {{type: import('../utils/build.mjs').BundleType, dir: string}[]} param0.bundles
- * @param {boolean} [param0.isFlat]
+ * @param {import('../utils/build.mjs').BundleType[]} param0.bundles
  * @param {'module' | 'commonjs'} [param0.packageType]
  * @returns
  */
-export async function moveAndTransformDeclarations({
-  inputDir,
-  buildDir,
-  bundles,
-  isFlat,
-  packageType,
-}) {
-  // Directly copy to the bundle directory if there's only one bundle, mainly for esm, since
-  // the js files are inside 'esm' folder. resolve-imports plugin needs d.ts to be alongside js files to
-  // resolve paths correctly.
-  const toCopyDir = bundles.length === 1 ? path.join(buildDir, bundles[0].dir) : buildDir;
-  await fs.cp(inputDir, toCopyDir, {
+export async function moveAndTransformDeclarations({ inputDir, buildDir, bundles, packageType }) {
+  // d.ts files sit alongside the js files in the build root so the resolve-imports
+  // plugin can resolve paths correctly.
+  await fs.cp(inputDir, buildDir, {
     recursive: true,
     force: false,
   });
 
-  const dtsFiles = await globby('**/*.d.ts', { absolute: true, cwd: toCopyDir });
+  const dtsFiles = await globby('**/*.d.ts', { absolute: true, cwd: buildDir });
   if (dtsFiles.length === 0) {
-    console.log(`No d.ts files found in ${toCopyDir}. Skipping transformation.`);
+    console.log(`No d.ts files found in ${buildDir}. Skipping transformation.`);
     return;
   }
 
@@ -144,37 +135,30 @@ export async function moveAndTransformDeclarations({
       // Normalize to native separators to make path comparisons reliable on Windows
       const nativeDtsFile = path.normalize(dtsFile);
       const content = await fs.readFile(nativeDtsFile, 'utf8');
-      const relativePath = path.relative(toCopyDir, nativeDtsFile);
+      const relativePath = path.relative(buildDir, nativeDtsFile);
 
-      const writesToOriginalPath =
-        isFlat &&
-        bundles.some((bundle) => {
-          const newFileExtension = getOutExtension(bundle.type, {
-            isFlat,
-            isType: true,
-            packageType,
-          });
-          const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
-          const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
-          // Ensure both paths are normalized before comparison (fixes Windows posix vs win32 separators)
-          return path.resolve(outFilePath) === path.resolve(nativeDtsFile);
+      const writesToOriginalPath = bundles.some((bundle) => {
+        const newFileExtension = getOutExtension(bundle, {
+          isType: true,
+          packageType,
         });
+        const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
+        const outFilePath = path.join(buildDir, outFileRelative);
+        // Ensure both paths are normalized before comparison (fixes Windows posix vs win32 separators)
+        return path.resolve(outFilePath) === path.resolve(nativeDtsFile);
+      });
 
       await Promise.all(
         bundles.map(async (bundle) => {
-          const importExtension = getOutExtension(bundle.type, {
-            isFlat,
+          const importExtension = getOutExtension(bundle, {
             packageType,
           });
-          const newFileExtension = getOutExtension(bundle.type, {
-            isFlat,
+          const newFileExtension = getOutExtension(bundle, {
             isType: true,
             packageType,
           });
-          const outFileRelative = isFlat
-            ? relativePath.replace(/\.d\.ts$/, newFileExtension)
-            : relativePath;
-          const outFilePath = path.join(buildDir, bundle.dir, outFileRelative);
+          const outFileRelative = relativePath.replace(/\.d\.ts$/, newFileExtension);
+          const outFilePath = path.join(buildDir, outFileRelative);
 
           const babelPlugins = [
             [pluginTypescriptSyntax, { dts: true }],
@@ -194,7 +178,7 @@ export async function moveAndTransformDeclarations({
           }
         }),
       );
-      if (isFlat && !writesToOriginalPath) {
+      if (!writesToOriginalPath) {
         await fs.unlink(nativeDtsFile);
       }
     },
@@ -208,9 +192,8 @@ export async function moveAndTransformDeclarations({
  * After copying, babel transformations are applied to the copied files because they need to be alongside the actual js files for proper resolution.
  *
  * @param {Object} param0
- * @param {boolean} [param0.isFlat = false] - Whether to place generated declaration files in a flattened directory.
  * @param {boolean} [param0.verbose = false] - Whether to log additional information while generating and moving declaration files.
- * @param {{type: import('../utils/build.mjs').BundleType, dir: string}[]} param0.bundles - The bundles to create declarations for.
+ * @param {import('../utils/build.mjs').BundleType[]} param0.bundles - The bundles to create declarations for.
  * @param {string} param0.srcDir - The source directory.
  * @param {string} param0.buildDir - The build directory.
  * @param {string} param0.cwd - The current working directory.
@@ -225,7 +208,6 @@ export async function createTypes({
   cwd,
   skipTsc,
   useTsgo = false,
-  isFlat = false,
   packageType,
   verbose,
 }) {
@@ -253,7 +235,6 @@ export async function createTypes({
       inputDir: tmpDir,
       buildDir,
       bundles,
-      isFlat,
       packageType,
     });
   } finally {

package/src/utils/typescript.test.mjs

@@ -118,8 +118,8 @@ describe('moveAndTransformDeclarations', () => {
       createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
     ]);
 
-    /** @type {{type: BundleType; dir: string}[]} */
-    const bundles = [{ type: 'esm', dir: 'esm' }];
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
 
     // Mock babel transformAsync to avoid actual babel transformations
     vi.doMock('@babel/core', () => ({
@@ -130,18 +130,17 @@ describe('moveAndTransformDeclarations', () => {
       inputDir,
       buildDir,
       bundles,
-      isFlat: false,
       packageType: 'module',
     });
 
     // Verify file exists in the correct location
-    const dtsFile = path.join(buildDir, 'esm', 'index.d.ts');
+    const dtsFile = path.join(buildDir, 'index.d.ts');
     const stat = await fs.stat(dtsFile).catch(() => null);
     expect(stat).not.toBeNull();
     expect(stat?.isFile()).toBe(true);
   });
 
-  it('preserves original path file when not flat build', async () => {
+  it('preserves original path file for a single esm bundle', async () => {
     const cwd = await makeTempDir();
     const inputDir = path.join(cwd, 'input');
     const buildDir = path.join(cwd, 'build');
@@ -151,19 +150,18 @@ describe('moveAndTransformDeclarations', () => {
       createFile(path.join(inputDir, 'index.d.ts'), 'export const test: string;'),
     ]);
 
-    /** @type {{type: BundleType; dir: string}[]} */
-    const bundles = [{ type: 'esm', dir: 'esm' }];
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
 
     await moveAndTransformDeclarations({
       inputDir,
       buildDir,
       bundles,
-      isFlat: false,
       packageType: 'module',
     });
 
-    // For single bundle non-flat builds, files are copied to bundle dir
-    const dtsFile = path.join(buildDir, 'esm', 'index.d.ts');
+    // Files are copied to the build root
+    const dtsFile = path.join(buildDir, 'index.d.ts');
     const stat = await fs.stat(dtsFile).catch(() => null);
     expect(stat?.isFile()).toBe(true);
   });
@@ -189,8 +187,8 @@ describe('moveAndTransformDeclarations', () => {
     const content = 'export const normalized: boolean;';
     await Promise.all([createFile(path.join(inputDir, 'test.d.ts'), content)]);
 
-    /** @type {{type: BundleType; dir: string}[]} */
-    const bundles = [{ type: 'esm', dir: 'esm' }];
+    /** @type {BundleType[]} */
+    const bundles = ['esm'];
 
     // Mock babel transformAsync to capture filename
     const transformMock = vi.fn(async (code) => ({ code }));
@@ -202,12 +200,11 @@ describe('moveAndTransformDeclarations', () => {
       inputDir,
       buildDir,
       bundles,
-      isFlat: false,
       packageType: 'module',
     });
 
     // Verify the file was read correctly by checking it exists
-    const dtsFile = path.join(buildDir, 'esm', 'test.d.ts');
+    const dtsFile = path.join(buildDir, 'test.d.ts');
     const stat = await fs.stat(dtsFile).catch(() => null);
     expect(stat?.isFile()).toBe(true);
   });
@@ -220,20 +217,19 @@ describe('moveAndTransformDeclarations', () => {
     const content = 'export const flat: string;';
     await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
 
-    /** @type {{type: BundleType; dir: string}[]} */
+    /** @type {BundleType[]} */
     // ESM + module packageType keeps .d.ts extension in flat builds
-    const bundles = [{ type: 'esm', dir: 'esm' }];
+    const bundles = ['esm'];
 
     await moveAndTransformDeclarations({
       inputDir,
       buildDir,
       bundles,
-      isFlat: true,
       packageType: 'module',
     });
 
     // Since extension doesn't change (.d.ts -> .d.ts), file should remain
-    const outputFile = path.join(buildDir, 'esm', 'index.d.ts');
+    const outputFile = path.join(buildDir, 'index.d.ts');
     const outputStat = await fs.stat(outputFile).catch(() => null);
     expect(outputStat?.isFile()).toBe(true);
   });
@@ -245,26 +241,25 @@ describe('moveAndTransformDeclarations', () => {
 
     const content = 'export const transformed: string;';
     await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
-    /** @type {{type: BundleType; dir: string}[]} */
+    /** @type {BundleType[]} */
 
     // CJS bundle with module packageType creates .d.cts
-    const bundles = [{ type: 'cjs', dir: 'cjs' }];
+    const bundles = ['cjs'];
 
     await moveAndTransformDeclarations({
       inputDir,
       buildDir,
       bundles,
-      isFlat: true,
       packageType: 'module',
     });
 
     // Transformed file with new extension should exist
-    const outputFile = path.join(buildDir, 'cjs', 'index.d.cts');
+    const outputFile = path.join(buildDir, 'index.d.cts');
     const outputStat = await fs.stat(outputFile).catch(() => null);
     expect(outputStat?.isFile()).toBe(true);
 
     // Original .d.ts should be removed
-    const originalFile = path.join(buildDir, 'cjs', 'index.d.ts');
+    const originalFile = path.join(buildDir, 'index.d.ts');
     const originalStat = await fs.stat(originalFile).catch(() => null);
     expect(originalStat).toBeNull();
   });
@@ -291,26 +286,25 @@ describe('moveAndTransformDeclarations', () => {
 
     const content = 'export const component: string;';
     await Promise.all([createFile(path.join(inputDir, 'component.d.ts'), content)]);
-    /** @type {{type: BundleType; dir: string}[]} */
+    /** @type {BundleType[]} */
 
     // ESM + commonjs packageType creates .d.mts
-    const bundles = [{ type: 'esm', dir: 'esm' }];
+    const bundles = ['esm'];
 
     await moveAndTransformDeclarations({
       inputDir,
       buildDir,
       bundles,
-      isFlat: true,
       packageType: 'commonjs',
     });
 
     // The .d.mts file should exist
-    const transformedFile = path.join(buildDir, 'esm', 'component.d.mts');
+    const transformedFile = path.join(buildDir, 'component.d.mts');
     const transformedStat = await fs.stat(transformedFile).catch(() => null);
     expect(transformedStat?.isFile()).toBe(true);
 
     // Original .d.ts should be removed because extension changed
-    const originalFile = path.join(buildDir, 'esm', 'component.d.ts');
+    const originalFile = path.join(buildDir, 'component.d.ts');
     const originalStat = await fs.stat(originalFile).catch(() => null);
     expect(originalStat).toBeNull();
   });
@@ -323,35 +317,25 @@ describe('moveAndTransformDeclarations', () => {
     const content = 'export const multi: string;';
     await Promise.all([createFile(path.join(inputDir, 'index.d.ts'), content)]);
 
-    // Multiple bundles: files are copied to buildDir, not directly to bundle dirs
-    /** @type {{type: BundleType; dir: string}[]} */
-    const bundles = [
-      { type: 'esm', dir: 'esm' },
-      { type: 'cjs', dir: 'cjs' },
-    ];
+    /** @type {BundleType[]} */
+    const bundles = ['esm', 'cjs'];
 
     await moveAndTransformDeclarations({
       inputDir,
       buildDir,
       bundles,
-      isFlat: true,
       packageType: 'module',
     });
 
-    // Each bundle gets its own transformed copy
-    // ESM with module packageType keeps .d.ts
-    const esmFile = path.join(buildDir, 'esm', 'index.d.ts');
+    // Each bundle writes its own transformed copy to the build root.
+    // ESM with module packageType keeps .d.ts (and is the original, so it stays)
+    const esmFile = path.join(buildDir, 'index.d.ts');
     const esmStat = await fs.stat(esmFile).catch(() => null);
     expect(esmStat?.isFile()).toBe(true);
 
     // CJS with module packageType gets .d.cts
-    const cjsFile = path.join(buildDir, 'cjs', 'index.d.cts');
+    const cjsFile = path.join(buildDir, 'index.d.cts');
     const cjsStat = await fs.stat(cjsFile).catch(() => null);
     expect(cjsStat?.isFile()).toBe(true);
-
-    // Original in buildDir should be removed in flat mode since writesToOriginalPath is false
-    const originalFile = path.join(buildDir, 'index.d.ts');
-    const originalStat = await fs.stat(originalFile).catch(() => null);
-    expect(originalStat).toBeNull();
   });
 });