[infra] Abstract tsdown based build-new command

This is done in a way so that we could potentially remove/replace tsdown
in future with a new bundler (if required).
Also, this doesn't change our current `code-infra build` command with
flags.

Author: brijeshb42

packages/code-infra/bin/code-infra.mjs

@@ -17,7 +17,7 @@
     "./babel-config": "./src/babel-config.mjs"
   },
   "bin": {
-    "code-infra": "./bin/code-infra.mjs"
+    "code-infra": "./src/bin/code-infra.mjs"
   },
   "scripts": {
     "typescript": "tsc -p tsconfig.json",
@@ -70,8 +70,14 @@
   "peerDependencies": {
     "eslint": "^9.0.0",
     "prettier": "^3.5.3",
+    "tsdown": "^0.14.2",
     "typescript": "^5.0.0"
   },
+  "peerDependenciesMeta": {
+    "tsdown": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/babel__preset-env": "^7.10.0",
@@ -86,13 +92,6 @@
     "prettier": "^3.6.2",
     "typescript-eslint": "^8.40.0"
   },
-  "files": [
-    "bin",
-    "build",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
   "publishConfig": {
     "access": "public"
   }

packages/code-infra/package.json

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from '../cli/index.mjs';
+
+run();

packages/code-infra/src/bin/code-infra.mjs

@@ -0,0 +1,174 @@
+import { builtinModules } from 'node:module';
+import * as fs from 'node:fs/promises';
+import { build as tsdown } from 'tsdown';
+import {
+  getTsConfigPath,
+  getVersionEnvVariables,
+  processExportsToEntry,
+  writePkgJson,
+} from '../utils/build.mjs';
+
+/**
+ * @typedef {import('../cli/cmdBuildNew.mjs').BaseArgs} Args
+ */
+
+/**
+ * @typedef {import('../cli/cmdBuildNew.mjs').PackageJson} PackageJson
+ */
+
+/**
+ * @param {Args} args
+ * @param {PackageJson} pkgJson
+ * @returns {Promise<void>}
+ */
+export async function build(args, pkgJson) {
+  const cwd = process.cwd();
+
+  const outDir = /** @type {any} */ (pkgJson.publishConfig)?.directory;
+  await fs.rm(outDir, {
+    recursive: true,
+    force: true,
+  });
+
+  const [exportEntries, , binEntries] = await processExportsToEntry(
+    pkgJson.exports ?? {},
+    pkgJson.bin ?? {},
+    { cwd },
+  );
+  const externals = new Set([
+    ...Object.keys(pkgJson.dependencies || {}),
+    ...Object.keys(pkgJson.peerDependencies || {}),
+  ]);
+  /**
+   * @type {(string|RegExp)[]}
+   */
+  const externalsArray = Array.from(externals);
+  externalsArray.push(new RegExp(`^(${externalsArray.join('|')})/`));
+  externalsArray.push(/^node:/);
+  externalsArray.push(...builtinModules);
+
+  const tsconfigPath = await getTsConfigPath(cwd);
+  const bannerText = `/**
+ * ${pkgJson.name} v${pkgJson.version}
+ *
+ * @license ${pkgJson.license ?? 'MIT'}
+ * This source code is licensed under the ${pkgJson.license} license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+`;
+
+  /**
+   * @type {import('tsdown').Options}
+   */
+  const baseOptions = {
+    watch: args.watch || false,
+    config: false,
+    outDir,
+    unbundle: true,
+    clean: false,
+    skipNodeModulesBundle: true,
+    external: externalsArray,
+    platform: 'neutral',
+    ignoreWatch: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+    env: {
+      ...getVersionEnvVariables(pkgJson.version ?? ''),
+    },
+    loader: {
+      '.js': 'jsx',
+    },
+    logLevel: args.verbose ? 'info' : 'silent',
+    tsconfig: tsconfigPath ?? undefined,
+    sourcemap: false,
+    banner: {
+      js: bannerText,
+      dts: bannerText,
+      css: bannerText,
+    },
+    minify: 'dce-only',
+  };
+
+  /**
+   * @type {Promise<void>[]}
+   */
+  const promises = [];
+
+  /**
+   * @type {Record<string, {paths: string[]; isBin?: boolean}>}
+   */
+  const outChunks = {};
+
+  if (Object.keys(exportEntries).length > 0) {
+    args.bundle.forEach((format) => {
+      promises.push(
+        tsdown({
+          ...baseOptions,
+          entry: exportEntries,
+          format,
+          dts: tsconfigPath
+            ? {
+                cwd,
+                tsconfig: tsconfigPath,
+                emitJs: false,
+                compilerOptions: {
+                  jsx: 'react-jsx',
+                  outDir,
+                },
+              }
+            : false,
+          outputOptions: {
+            plugins: [
+              {
+                name: `get-output-chunks-${format}`,
+                writeBundle(_ctx, chunks) {
+                  Object.entries(chunks).forEach(([fileName, chunk]) => {
+                    if (chunk.type !== 'chunk' || !chunk.isEntry) {
+                      return;
+                    }
+                    const chunkName = chunk.name.endsWith('.d')
+                      ? chunk.name.slice(0, -2)
+                      : chunk.name;
+                    outChunks[chunkName] = outChunks[chunkName] || { paths: [] };
+                    outChunks[chunkName].paths.push(fileName);
+                  });
+                },
+              },
+            ],
+          },
+        }),
+      );
+    });
+  }
+
+  if (Object.keys(binEntries).length > 0) {
+    const format = pkgJson.type === 'module' ? 'esm' : 'cjs';
+    promises.push(
+      tsdown({
+        ...baseOptions,
+        tsconfig: undefined,
+        entry: binEntries,
+        format,
+        platform: 'node',
+        outputOptions: {
+          plugins: [
+            {
+              name: 'get-output-chunks-bin',
+              writeBundle(_ctx, chunks) {
+                Object.entries(chunks).forEach(([fileName, chunk]) => {
+                  if (chunk.type !== 'chunk' || !chunk.isEntry) {
+                    return;
+                  }
+                  outChunks[chunk.name] = outChunks[chunk.name] || { paths: [], isBin: true };
+                  outChunks[chunk.name].paths.push(fileName);
+                });
+              },
+            },
+          ],
+        },
+      }),
+    );
+  }
+  await Promise.all(promises);
+  await writePkgJson(pkgJson, outChunks, {
+    usePkgType: true,
+  });
+}

packages/code-infra/src/bundlers/tsdown.mjs

@@ -308,6 +308,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     } = args;
 
     const cwd = process.cwd();
+    performance.mark('build-start');
     const pkgJsonPath = path.join(cwd, 'package.json');
     const packageJson = JSON.parse(await fs.readFile(pkgJsonPath, { encoding: 'utf8' }));
     const buildDirBase = packageJson.publishConfig?.directory;
@@ -443,5 +444,8 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       outputDir: buildDir,
       addTypes: buildTypes,
     });
+    performance.mark('build-end');
+    const measure = performance.measure('build', 'build-start', 'build-end');
+    console.log(`✅ Built "${packageJson.name}" in ${(measure.duration / 1000).toFixed(3)}s.`);
   },
 });

packages/code-infra/src/cli/cmdBuild.mjs

@@ -0,0 +1,122 @@
+/* eslint-disable no-console */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { validatePkgJson } from '../utils/build.mjs';
+
+/**
+ * @typedef {import('./cmdBuild.mjs').Args & {watch?: boolean}} BaseArgs
+ */
+
+/**
+ * @typedef {BaseArgs & { bundler: 'tsdown' }} Args
+ */
+
+/**
+ * @typedef {Partial<import('../../package.json')>} PackageJson
+ */
+
+/**
+ * @type {import('../utils/build.mjs').BundleType[]}
+ */
+const validBundles = ['esm', 'cjs'];
+
+/**
+ * @type {Args['bundler'][]}
+ */
+const validBundlers = ['tsdown'];
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'build-new',
+  describe: 'Builds the package for publishing.',
+  builder(yargs) {
+    return yargs
+      .option('bundler', {
+        demandOption: true,
+        type: 'string',
+        choices: validBundlers,
+        description: 'The bundler to use for building the package.',
+        default: 'tsdown',
+      })
+      .option('bundle', {
+        array: true,
+        demandOption: true,
+        type: 'string',
+        choices: validBundles,
+        description: 'Bundles to output',
+        default: ['esm', 'cjs'],
+      })
+      .option('hasLargeFiles', {
+        type: 'boolean',
+        default: false,
+        describe: 'Set to `true` if you know you are transpiling large files.',
+      })
+      .option('skipBundlePackageJson', {
+        type: 'boolean',
+        default: false,
+        describe:
+          "Set to `true` if you don't want to generate a package.json file in the bundle output.",
+      })
+      .option('cjsOutDir', {
+        default: '.',
+        type: 'string',
+        description: 'The directory to output the cjs files to.',
+      })
+      .option('verbose', {
+        type: 'boolean',
+        default: false,
+        description: 'Enable verbose logging.',
+      })
+      .option('buildTypes', {
+        type: 'boolean',
+        default: true,
+        description: 'Whether to build types for the package.',
+      })
+      .option('skipTsc', {
+        type: 'boolean',
+        default: false,
+        description: 'Skip running TypeScript compiler (tsc) for building types.',
+      })
+      .option('ignore', {
+        type: 'string',
+        array: true,
+        description: 'Extra globs to be ignored by Babel.',
+        default: [],
+      })
+      .option('skipBabelRuntimeCheck', {
+        type: 'boolean',
+        default: false,
+        description: 'Skip checking for Babel runtime dependencies in the package.',
+      })
+      .option('skipPackageJson', {
+        type: 'boolean',
+        default: false,
+        description: 'Skip generating the package.json file in the bundle output.',
+      })
+      .option('watch', {
+        type: 'boolean',
+        default: false,
+        description: 'Watch files for changes and rebuild automatically.',
+      });
+  },
+  async handler({ bundler, ...args }) {
+    const cwd = process.cwd();
+    performance.mark('build-start');
+    const pkgJson = JSON.parse(await fs.readFile(path.join(cwd, 'package.json'), 'utf8'));
+
+    if (!bundler) {
+      throw new Error('No bundler specified');
+    }
+    console.log(`⚒️ Building ${pkgJson.name} using 📦 "${bundler}"`);
+    validatePkgJson(pkgJson);
+
+    switch (bundler) {
+      case 'tsdown':
+      default:
+        await import('../bundlers/tsdown.mjs').then(({ build }) => build(args, pkgJson));
+        break;
+    }
+    performance.mark('build-end');
+    const measure = performance.measure('build', 'build-start', 'build-end');
+    console.log(`✅ Built "${pkgJson.name}" in ${(measure.duration / 1000).toFixed(3)}s.`);
+  },
+});