@mui/internal-code-infra 0.0.3-canary.7 → 0.0.3-canary.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.3-canary.7",
+  "version": "0.0.3-canary.8",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "type": "module",
   "license": "MIT",
@@ -93,7 +93,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "509594de98a145e15241d136d9cd7b3fc4016f9a",
+  "gitSha": "0224fd29f46991b95d9489c62cd138e10dccd65a",
   "scripts": {
     "typescript": "tsc -p tsconfig.json",
     "test": "pnpm -w test --project @mui/internal-code-infra",

package/src/cli/cmdBuild.mjs

@@ -1,9 +1,13 @@
 /* eslint-disable no-console */
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
+import { globby } from 'globby';
 import set from 'lodash-es/set.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs';
+import { sep as posixSep } from 'node:path/posix';
+
+import { getOutExtension, isMjsBuild, mapConcurrently, validatePkgJson } from '../utils/build.mjs';
 
 /**
  * @typedef {Object} Args
@@ -18,6 +22,7 @@ import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs
  * @property {boolean} skipPackageJson - Whether to skip generating the package.json file in the bundle output.
  * @property {boolean} skipMainCheck - Whether to skip checking for main field in package.json.
  * @property {string[]} ignore - Globs to be ignored by Babel.
+ * @property {string[]} [copy] - Files/Directories to be copied. Can be a glob pattern.
  */
 
 const validBundles = [
@@ -298,6 +303,13 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         type: 'boolean',
         default: false,
         description: 'Skip checking for main field in package.json.',
+      })
+      .option('copy', {
+        type: 'string',
+        array: true,
+        description:
+          'Files/Directories to be copied to the output directory. Can be a glob pattern.',
+        default: [],
       });
   },
   async handler(args) {
@@ -442,5 +454,144 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       outputDir: buildDir,
       addTypes: buildTypes,
     });
+
+    await copyHandler({
+      cwd,
+      globs: args.copy ?? [],
+      buildDir,
+      verbose: args.verbose,
+    });
   },
 });
+
+/**
+ * @param {Object} param0
+ * @param {string} param0.cwd - The current working directory.
+ * @param {string[]} [param0.globs=[]] - Extra files to copy, can be specified as `source:target` pairs or just `source`.
+ * @param {string} param0.buildDir - The build directory to copy to.
+ * @param {boolean} [param0.verbose=false] - Whether to suppress output.
+ * @returns {Promise<void>}
+ */
+async function copyHandler({ cwd, globs = [], buildDir, verbose = false }) {
+  /**
+   * @type {(string|{targetPath: string; sourcePath: string})[]}
+   */
+  const defaultFiles = [];
+  const workspaceDir = await findWorkspaceDir(cwd);
+  if (!workspaceDir) {
+    throw new Error('Workspace directory not found');
+  }
+
+  const localOrRootFiles = [
+    [path.join(cwd, 'README.md'), path.join(workspaceDir, 'README.md')],
+    [path.join(cwd, 'LICENSE'), path.join(workspaceDir, 'LICENSE')],
+    [path.join(cwd, 'CHANGELOG.md'), path.join(workspaceDir, 'CHANGELOG.md')],
+  ];
+  await Promise.all(
+    localOrRootFiles.map(async (filesToCopy) => {
+      for (const file of filesToCopy) {
+        if (
+          // eslint-disable-next-line no-await-in-loop
+          await fs.stat(file).then(
+            () => true,
+            () => false,
+          )
+        ) {
+          defaultFiles.push(file);
+          break;
+        }
+      }
+    }),
+  );
+
+  if (globs.length) {
+    const res = globs.map((globPattern) => {
+      const [pattern, baseDir] = globPattern.split(':');
+      return { pattern, baseDir };
+    });
+    /**
+     * Avoids redundant globby calls for the same pattern.
+     *
+     * @type {Map<string, Promise<string[]>>}
+     */
+    const globToResMap = new Map();
+
+    const result = await Promise.all(
+      res.map(async ({ pattern, baseDir }) => {
+        if (!globToResMap.has(pattern)) {
+          const promise = globby(pattern, { cwd });
+          globToResMap.set(pattern, promise);
+        }
+        const files = await globToResMap.get(pattern);
+        return { files: files ?? [], baseDir };
+      }),
+    );
+    globToResMap.clear();
+
+    result.forEach(({ files, baseDir }) => {
+      files.forEach((file) => {
+        const sourcePath = path.resolve(cwd, file);
+        // Use posix separator for the relative paths. So devs can only specify globs with `/` even on Windows.
+        const pathSegments = file.split(posixSep);
+        const relativePath =
+          // Use index 2 (when required) since users can also specify paths like `./src/index.js`
+          pathSegments.slice(pathSegments[0] === '.' ? 2 : 1).join(posixSep) || file;
+        const targetPath = baseDir
+          ? path.resolve(buildDir, baseDir, relativePath)
+          : path.resolve(buildDir, relativePath);
+        defaultFiles.push({ sourcePath, targetPath });
+      });
+    });
+  }
+
+  if (!defaultFiles.length) {
+    if (verbose) {
+      console.log('⓿ No files to copy.');
+    }
+  }
+  await mapConcurrently(
+    defaultFiles,
+    async (file) => {
+      if (typeof file === 'string') {
+        const sourcePath = file;
+        const fileName = path.basename(file);
+        const targetPath = path.join(buildDir, fileName);
+        await recursiveCopy({ source: sourcePath, target: targetPath, verbose });
+      } else {
+        await fs.mkdir(path.dirname(file.targetPath), { recursive: true });
+        await recursiveCopy({ source: file.sourcePath, target: file.targetPath, verbose });
+      }
+    },
+    20,
+  );
+  console.log(`📋 Copied ${defaultFiles.length} files.`);
+}
+
+/**
+ * Recursively copies files and directories from a source path to a target path.
+ *
+ * @async
+ * @param {Object} options - The options for copying files.
+ * @param {string} options.source - The source path to copy from.
+ * @param {string} options.target - The target path to copy to.
+ * @param {boolean} [options.verbose=true] - If true, suppresses console output.
+ * @returns {Promise<boolean>} Resolves when the copy operation is complete.
+ * @throws {Error} Throws if an error occurs other than the source not existing.
+ */
+async function recursiveCopy({ source, target, verbose = true }) {
+  try {
+    await fs.cp(source, target, { recursive: true });
+    if (verbose) {
+      console.log(`Copied ${source} to ${target}`);
+    }
+    return true;
+  } catch (err) {
+    if (/** @type {{ code: string }} */ (err).code !== 'ENOENT') {
+      throw err;
+    }
+    if (verbose) {
+      console.warn(`Source does not exist: ${source}`);
+    }
+    throw err;
+  }
+}

package/src/cli/typescript.mjs

@@ -8,6 +8,7 @@ import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { mapConcurrently } from '../utils/build.mjs';
 
 const $$ = $({ stdio: 'inherit' });
 
@@ -27,7 +28,8 @@ export async function emitDeclarations(tsconfig, outDir) {
     --emitDeclarationOnly
     --noEmit false
     --composite false
-    --incremental false`;
+    --incremental false
+    --declarationMap false`;
 }
 
 /**
@@ -80,8 +82,9 @@ async function postProcessDeclarations({ directory }) {
     [pluginRemoveImports, { test: /\.css$/ }],
   ];
 
-  await Promise.all(
-    dtsFiles.map(async (dtsFile) => {
+  await mapConcurrently(
+    dtsFiles,
+    async (dtsFile) => {
       const result = await babel.transformFileAsync(dtsFile, {
         configFile: false,
         plugins: babelPlugins,
@@ -92,7 +95,8 @@ async function postProcessDeclarations({ directory }) {
       } else {
         console.error('failed to transform', dtsFile);
       }
-    }),
+    },
+    20,
   );
 }
 
@@ -107,11 +111,13 @@ async function renameDeclarations({ directory }) {
     return;
   }
   console.log(`Renaming d.ts files to d.mts in ${directory}`);
-  await Promise.all(
-    dtsFiles.map(async (dtsFile) => {
+  await mapConcurrently(
+    dtsFiles,
+    async (dtsFile) => {
       const newFileName = dtsFile.replace(/\.d\.ts$/, '.d.mts');
       await fs.rename(dtsFile, newFileName);
-    }),
+    },
+    20,
   );
 }