feat: omit commonjs mode (#112)

* feat: disable commonjs output

* chore: add changeset

Author: n1ru4l

.changeset/brown-deers-hammer.md

@@ -0,0 +1,14 @@
+---
+"bob-the-bundler": minor
+---
+
+Disable commonjs output via package.json
+
+```json
+{
+  "name": "my-package",
+  "bob": {
+    "commonjs": false
+  }
+}
+```

src/commands/bootstrap.ts

@@ -34,19 +34,32 @@ export const presetFields = Object.freeze({
         default: "./dist/esm/index.js",
       },
     },
-    "./*": {
-      require: {
-        types: "./dist/typings/*.d.ts",
-        default: "./dist/cjs/*.js",
-      },
+    "./package.json": "./package.json",
+  },
+  publishConfig: {
+    directory: "dist",
+    access: "public",
+  },
+});
+
+export const presetFieldsESM = {
+  type: "module",
+  main: "dist/esm/index.js",
+  module: "dist/esm/index.js",
+  typings: "dist/typings/index.d.ts",
+  typescript: {
+    definition: "dist/typings/index.d.ts",
+  },
+  exports: {
+    ".": {
       import: {
-        types: "./dist/typings/*.d.ts",
-        default: "./dist/esm/*.js",
+        types: "./dist/typings/index.d.ts",
+        default: "./dist/esm/index.js",
       },
       /** without this default (THAT MUST BE LAST!!!) webpack will have a midlife crisis. */
       default: {
-        types: "./dist/typings/*.d.ts",
-        default: "./dist/esm/*.js",
+        types: "./dist/typings/index.d.ts",
+        default: "./dist/esm/index.js",
       },
     },
     "./package.json": "./package.json",
@@ -55,7 +68,7 @@ export const presetFields = Object.freeze({
     directory: "dist",
     access: "public",
   },
-});
+};
 
 async function applyESMModuleTransform(cwd: string) {
   const filePaths = await globby("**/*.ts", {

src/commands/build.ts

@@ -13,7 +13,7 @@ import { getWorkspaces } from "../utils/get-workspaces";
 import { createCommand } from "../command";
 import { getBobConfig } from "../config";
 import { rewriteExports } from "../utils/rewrite-exports";
-import { presetFields } from "./bootstrap";
+import { presetFields, presetFieldsESM } from "./bootstrap";
 import { getWorkspacePackagePaths } from "../utils/get-workspace-package-paths";
 
 export const DIST_DIR = "dist";
@@ -201,7 +201,7 @@ async function build({
     return;
   }
 
-  validatePackageJson(pkg);
+  validatePackageJson(pkg, config?.commonjs ?? true);
 
   // remove <project>/dist
   await fse.remove(distPath);
@@ -246,31 +246,33 @@ async function build({
     )
   );
 
-  // Transpile ESM to CJS and move CJS to dist/cjs
-  await fse.ensureDir(join(distPath, "cjs"));
-
-  const cjsFiles = await globby("**/*.js", {
-    cwd: getBuildPath("cjs"),
-    absolute: false,
-    ignore: filesToExcludeFromDist,
-  });
-
-  await Promise.all(
-    cjsFiles.map((filePath) =>
-      limit(() =>
-        fse.copy(
-          join(getBuildPath("cjs"), filePath),
-          join(distPath, "cjs", filePath)
+  if (config?.commonjs === undefined) {
+    // Transpile ESM to CJS and move CJS to dist/cjs
+    await fse.ensureDir(join(distPath, "cjs"));
+
+    const cjsFiles = await globby("**/*.js", {
+      cwd: getBuildPath("cjs"),
+      absolute: false,
+      ignore: filesToExcludeFromDist,
+    });
+
+    await Promise.all(
+      cjsFiles.map((filePath) =>
+        limit(() =>
+          fse.copy(
+            join(getBuildPath("cjs"), filePath),
+            join(distPath, "cjs", filePath)
+          )
         )
       )
-    )
-  );
+    );
 
-  // Add package.json to dist/cjs to ensure files are interpreted as commonjs
-  await fse.writeFile(
-    join(distPath, "cjs", "package.json"),
-    JSON.stringify({ type: "commonjs" })
-  );
+    // Add package.json to dist/cjs to ensure files are interpreted as commonjs
+    await fse.writeFile(
+      join(distPath, "cjs", "package.json"),
+      JSON.stringify({ type: "commonjs" })
+    );
+  }
 
   // move the package.json to dist
   await fse.writeFile(
@@ -358,16 +360,15 @@ function rewritePackageJson(pkg: Record<string, any>) {
   return newPkg;
 }
 
-export function validatePackageJson(pkg: any) {
+export function validatePackageJson(pkg: any, includesCommonJS: boolean) {
   function expect(key: string, expected: unknown) {
     const received = get(pkg, key);
 
     assert.deepEqual(
       received,
       expected,
       `${pkg.name}: "${key}" equals "${JSON.stringify(received)}"` +
-        `, should be "${JSON.stringify(expected)}".\n` +
-        `!!! You can run 'bob bootstrap' for fixing your package.json. !!!`
+        `, should be "${JSON.stringify(expected)}".`
     );
   }
 
@@ -376,28 +377,45 @@ export function validatePackageJson(pkg: any) {
   // 1. have a bin property
   // 2. have a exports property
   // 3. have an exports and bin property
-  if (Object.keys(pkg.bin ?? {}).length === 0) {
-    expect("main", presetFields.main);
-    expect("module", presetFields.module);
-    expect("typings", presetFields.typings);
-    expect("typescript.definition", presetFields.typescript.definition);
+  if (Object.keys(pkg.bin ?? {}).length > 0) {
+    if (includesCommonJS === true) {
+      expect("main", presetFields.main);
+      expect("module", presetFields.module);
+      expect("typings", presetFields.typings);
+      expect("typescript.definition", presetFields.typescript.definition);
+    } else {
+      expect("main", presetFieldsESM.main);
+      expect("module", presetFieldsESM.module);
+      expect("typings", presetFieldsESM.typings);
+      expect("typescript.definition", presetFieldsESM.typescript.definition);
+    }
   } else if (
     pkg.main !== undefined ||
     pkg.module !== undefined ||
     pkg.exports !== undefined ||
     pkg.typings !== undefined ||
     pkg.typescript !== undefined
   ) {
-    // if there is no bin property, we NEED to check the exports.
-    expect("main", presetFields.main);
-    expect("module", presetFields.module);
-    expect("typings", presetFields.typings);
-    expect("typescript.definition", presetFields.typescript.definition);
-
-    // For now we enforce a top level exports property
-    expect("exports['.'].require", presetFields.exports["."].require);
-    expect("exports['.'].import", presetFields.exports["."].import);
-    expect("exports['.'].default", presetFields.exports["."].default);
+    if (includesCommonJS === true) {
+      // if there is no bin property, we NEED to check the exports.
+      expect("main", presetFields.main);
+      expect("module", presetFields.module);
+      expect("typings", presetFields.typings);
+      expect("typescript.definition", presetFields.typescript.definition);
+
+      // For now we enforce a top level exports property
+      expect("exports['.'].require", presetFields.exports["."].require);
+      expect("exports['.'].import", presetFields.exports["."].import);
+      expect("exports['.'].default", presetFields.exports["."].default);
+    } else {
+      expect("main", presetFieldsESM.main);
+      expect("module", presetFieldsESM.module);
+      expect("typings", presetFieldsESM.typings);
+      expect("typescript.definition", presetFieldsESM.typescript.definition);
+
+      // For now we enforce a top level exports property
+      expect("exports['.']", presetFieldsESM.exports["."]);
+    }
   }
 }
 

src/commands/check.ts

@@ -21,7 +21,7 @@ const ExportsMapModel = zod.record(
   zod.union([
     zod.string(),
     zod.object({
-      require: ExportsMapEntry,
+      require: zod.optional(ExportsMapEntry),
       import: ExportsMapEntry,
       default: ExportsMapEntry,
     }),
@@ -93,6 +93,7 @@ export const checkCommand = createCommand<{}, {}>((api) => {
                 cwd: path.join(cwd, "dist"),
                 packageJSON: distPackageJSON,
                 skipExports: new Set<string>(config?.check?.skip ?? []),
+                includesCommonJS: config?.commonjs ?? true,
               });
             } catch (err) {
               api.reporter.error(
@@ -121,6 +122,7 @@ async function checkExportsMapIntegrity(args: {
     bin: unknown;
   };
   skipExports: Set<string>;
+  includesCommonJS: boolean;
 }) {
   const exportsMapResult = ExportsMapModel.safeParse(
     args.packageJSON["exports"]
@@ -139,11 +141,13 @@ async function checkExportsMapIntegrity(args: {
   const cjsSkipExports = new Set<string>();
   const esmSkipExports = new Set<string>();
   for (const definedExport of args.skipExports) {
-    const cjsResult = resolve.resolve(args.packageJSON, definedExport, {
-      require: true,
-    });
-    if (typeof cjsResult === "string") {
-      cjsSkipExports.add(cjsResult);
+    if (args.includesCommonJS) {
+      const cjsResult = resolve.resolve(args.packageJSON, definedExport, {
+        require: true,
+      });
+      if (typeof cjsResult === "string") {
+        cjsSkipExports.add(cjsResult);
+      }
     }
     const esmResult = resolve.resolve(args.packageJSON, definedExport);
     if (typeof esmResult === "string") {
@@ -152,49 +156,51 @@ async function checkExportsMapIntegrity(args: {
   }
 
   for (const key of Object.keys(exportsMap)) {
-    const cjsResult = resolve.resolve(args.packageJSON, key, {
-      require: true,
-    });
+    if (args.includesCommonJS) {
+      const cjsResult = resolve.resolve(args.packageJSON, key, {
+        require: true,
+      });
 
-    if (!cjsResult) {
-      throw new Error(
-        `Could not resolve CommonJS import '${key}' for '${args.packageJSON.name}'.`
-      );
-    }
+      if (!cjsResult) {
+        throw new Error(
+          `Could not resolve CommonJS import '${key}' for '${args.packageJSON.name}'.`
+        );
+      }
 
-    if (cjsResult.match(/.(js|cjs)$/)) {
-      const cjsFilePaths = await globby(cjsResult, {
-        cwd: args.cwd,
-      });
+      if (cjsResult.match(/.(js|cjs)$/)) {
+        const cjsFilePaths = await globby(cjsResult, {
+          cwd: args.cwd,
+        });
 
-      const limit = pLimit(20);
-      await Promise.all(
-        cjsFilePaths.map((file) =>
-          limit(async () => {
-            if (cjsSkipExports.has(file)) {
-              return;
-            }
+        const limit = pLimit(20);
+        await Promise.all(
+          cjsFilePaths.map((file) =>
+            limit(async () => {
+              if (cjsSkipExports.has(file)) {
+                return;
+              }
 
-            const result = await runRequireJSFileCommand({
-              path: file,
-              cwd: args.cwd,
-            });
+              const result = await runRequireJSFileCommand({
+                path: file,
+                cwd: args.cwd,
+              });
 
-            if (result.exitCode !== 0) {
-              throw new Error(
-                `Require of file '${file}' failed.\n` +
-                  `In case this file is expected to raise an error please add an export to the 'bob.check.skip' field in your 'package.json' file.\n` +
-                  `Error:\n` +
-                  result.stderr
-              );
-            }
-          })
-        )
-      );
-    } else {
-      // package.json or other files
-      // for now we just make sure they exists
-      await fse.stat(path.join(args.cwd, cjsResult));
+              if (result.exitCode !== 0) {
+                throw new Error(
+                  `Require of file '${file}' failed.\n` +
+                    `In case this file is expected to raise an error please add an export to the 'bob.check.skip' field in your 'package.json' file.\n` +
+                    `Error:\n` +
+                    result.stderr
+                );
+              }
+            })
+          )
+        );
+      } else {
+        // package.json or other files
+        // for now we just make sure they exists
+        await fse.stat(path.join(args.cwd, cjsResult));
+      }
     }
 
     const esmResult = resolve.resolve({ exports: exportsMap }, key);
@@ -242,16 +248,31 @@ async function checkExportsMapIntegrity(args: {
   if (!legacyRequire || typeof legacyRequire !== "string") {
     throw new Error(`Could not resolve legacy CommonJS entrypoint.`);
   }
-  const legacyRequireResult = await runRequireJSFileCommand({
-    path: legacyRequire,
-    cwd: args.cwd,
-  });
 
-  if (legacyRequireResult.exitCode !== 0) {
-    throw new Error(
-      `Require of file '${legacyRequire}' failed with error:\n` +
-        legacyRequireResult.stderr
-    );
+  if (args.includesCommonJS) {
+    const legacyRequireResult = await runRequireJSFileCommand({
+      path: legacyRequire,
+      cwd: args.cwd,
+    });
+
+    if (legacyRequireResult.exitCode !== 0) {
+      throw new Error(
+        `Require of file '${legacyRequire}' failed with error:\n` +
+          legacyRequireResult.stderr
+      );
+    }
+  } else {
+    const legacyRequireResult = await runImportJSFileCommand({
+      path: legacyRequire,
+      cwd: args.cwd,
+    });
+
+    if (legacyRequireResult.exitCode !== 0) {
+      throw new Error(
+        `Require of file '${legacyRequire}' failed with error:\n` +
+          legacyRequireResult.stderr
+      );
+    }
   }
 
   const legacyImport = resolve.legacy(args.packageJSON);