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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.3-canary.6",
+  "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": "b76c4e6f0a445cd70cf69bb4513802a108d24e2c",
+  "gitSha": "0224fd29f46991b95d9489c62cd138e10dccd65a",
   "scripts": {
     "typescript": "tsc -p tsconfig.json",
     "test": "pnpm -w test --project @mui/internal-code-infra",

package/src/babel-config.mjs

@@ -13,7 +13,7 @@ import pluginRemovePropTypes from 'babel-plugin-transform-react-remove-prop-type
  * @param {boolean} [param0.debug]
  * @param {boolean} [param0.optimizeClsx]
  * @param {boolean} [param0.removePropTypes]
- * @param {boolean} [param0.isTest]
+ * @param {boolean} [param0.noResolveImports]
  * @param {'cjs' | 'esm'} param0.bundle
  * @param {string | null} param0.outExtension - Specify the output file extension.
  * @param {string} param0.runtimeVersion
@@ -23,7 +23,7 @@ export function getBaseConfig({
   debug = false,
   optimizeClsx = false,
   removePropTypes = false,
-  isTest = false,
+  noResolveImports = false,
   bundle,
   runtimeVersion,
   outExtension,
@@ -81,7 +81,7 @@ export function getBaseConfig({
     plugins.push([pluginOptimizeClsx, {}, 'babel-plugin-optimize-clsx']);
   }
 
-  if (bundle === 'esm' && !isTest) {
+  if (bundle === 'esm' && !noResolveImports) {
     plugins.push([
       pluginResolveImports,
       { outExtension },
@@ -119,20 +119,39 @@ export function getBaseConfig({
 }
 
 /**
- * @type {import('@babel/core').ConfigFunction}
+ * @typedef {Object} Options
+ * @prop {'esm' | 'cjs'} [Options.bundle]
+ * @prop {boolean} [Options.noResolveImports]
+ * @prop {undefined} [options.env]
+ */
+
+/**
+ * @param {import('@babel/core').ConfigAPI | Options} api
+ * @returns {import('@babel/core').TransformOptions}
  */
 export default function getBabelConfig(api) {
-  const isStable = api.env(['regressions', 'stable']);
-  const isTest = api.env('test') || process.env.NODE_ENV === 'test';
+  /** @type {'esm' | 'cjs'} */
+  let bundle;
+  /** @type {boolean} */
+  let noResolveImports;
+
+  if (api.env) {
+    // legacy
+    bundle = api.env(['regressions', 'stable']) ? 'esm' : 'cjs';
+    noResolveImports = api.env('test') || process.env.NODE_ENV === 'test';
+  } else {
+    bundle = api.bundle || 'esm';
+    noResolveImports = api.noResolveImports || false;
+  }
 
   return getBaseConfig({
     debug: process.env.MUI_BUILD_VERBOSE === 'true',
-    bundle: isStable ? 'esm' : 'cjs',
+    bundle,
     outExtension: process.env.MUI_OUT_FILE_EXTENSION || null,
     // any package needs to declare 7.25.0 as a runtime dependency. default is ^7.0.0
     runtimeVersion: process.env.MUI_BABEL_RUNTIME_VERSION || '^7.25.0',
     optimizeClsx: process.env.MUI_OPTIMIZE_CLSX === 'true',
     removePropTypes: process.env.MUI_REMOVE_PROP_TYPES === 'true',
-    isTest,
+    noResolveImports,
   });
 }

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,
   );
 }