Include empty cjs/esm entry points for types-only packages (#214)

Author: enisdenjo

.changeset/bright-ducks-agree.md

@@ -0,0 +1,5 @@
+---
+'bob-the-bundler': patch
+---
+
+Include empty cjs/esm entry points for types-only packages

src/commands/build.ts

@@ -207,60 +207,49 @@ async function build({
     return;
   }
 
+  validatePackageJson(pkg, {
+    includesCommonJS: config?.commonjs ?? true,
+  });
+
   const declarations = await globby('**/*.d.ts', {
     cwd: getBuildPath('esm'),
     absolute: false,
     ignore: filesToExcludeFromDist,
   });
 
+  await fse.ensureDir(join(distPath, 'typings'));
+  await Promise.all(
+    declarations.map(filePath =>
+      limit(() =>
+        fse.copy(join(getBuildPath('esm'), filePath), join(distPath, 'typings', filePath)),
+      ),
+    ),
+  );
+
   const esmFiles = await globby('**/*.js', {
     cwd: getBuildPath('esm'),
     absolute: false,
     ignore: filesToExcludeFromDist,
   });
 
-  // Check whether al esm files are empty, if not - probably a types only build
-  let emptyEsmFiles = true;
+  // all files that export nothing, should be completely empty
+  // this way we wont have issues with linters: <link to issue>
+  // and we will also make all type-only packages happy
   for (const file of esmFiles) {
     const src = await fse.readFile(join(getBuildPath('esm'), file));
-    if (src.toString().trim() !== 'export {};') {
-      emptyEsmFiles = false;
-      break;
+    if (src.toString().trim() === 'export {};') {
+      await fse.writeFile(join(getBuildPath('esm'), file), '');
     }
   }
 
-  // Empty ESM files with existing declarations is a types-only package
-  const typesOnly = emptyEsmFiles && declarations.length > 0;
-
-  validatePackageJson(pkg, {
-    typesOnly,
-    includesCommonJS: config?.commonjs ?? true,
-  });
-
-  // remove <project>/dist
-  await fse.remove(distPath);
-
-  // Copy type definitions
-  await fse.ensureDir(join(distPath, 'typings'));
+  await fse.ensureDir(join(distPath, 'esm'));
   await Promise.all(
-    declarations.map(filePath =>
-      limit(() =>
-        fse.copy(join(getBuildPath('esm'), filePath), join(distPath, 'typings', filePath)),
-      ),
+    esmFiles.map(filePath =>
+      limit(() => fse.copy(join(getBuildPath('esm'), filePath), join(distPath, 'esm', filePath))),
     ),
   );
 
-  // If ESM files are not empty, copy them to dist/esm
-  if (!emptyEsmFiles) {
-    await fse.ensureDir(join(distPath, 'esm'));
-    await Promise.all(
-      esmFiles.map(filePath =>
-        limit(() => fse.copy(join(getBuildPath('esm'), filePath), join(distPath, 'esm', filePath))),
-      ),
-    );
-  }
-
-  if (!emptyEsmFiles && config?.commonjs === undefined) {
+  if (config?.commonjs === undefined) {
     // Transpile ESM to CJS and move CJS to dist/cjs only if there's something to transpile
     await fse.ensureDir(join(distPath, 'cjs'));
 
@@ -270,6 +259,20 @@ async function build({
       ignore: filesToExcludeFromDist,
     });
 
+    // all files that export nothing, should be completely empty
+    // this way we wont have issues with linters: <link to issue>
+    // and we will also make all type-only packages happy
+    for (const file of cjsFiles) {
+      const src = await fse.readFile(join(getBuildPath('cjs'), file));
+      if (
+        // TODO: will this always be the case with empty cjs files
+        src.toString().trim() ===
+        '"use strict";\nObject.defineProperty(exports, "__esModule", { value: true });'
+      ) {
+        await fse.writeFile(join(getBuildPath('cjs'), file), '');
+      }
+    }
+
     await Promise.all(
       cjsFiles.map(filePath =>
         limit(() => fse.copy(join(getBuildPath('cjs'), filePath), join(distPath, 'cjs', filePath))),
@@ -305,7 +308,7 @@ async function build({
   // move the package.json to dist
   await fse.writeFile(
     join(distPath, 'package.json'),
-    JSON.stringify(rewritePackageJson(pkg, typesOnly), null, 2),
+    JSON.stringify(rewritePackageJson(pkg), null, 2),
   );
 
   // move README.md and LICENSE and other specified files
@@ -327,7 +330,7 @@ async function build({
   reporter.success(`Built ${pkg.name}`);
 }
 
-function rewritePackageJson(pkg: Record<string, any>, typesOnly: boolean) {
+function rewritePackageJson(pkg: Record<string, any>) {
   const newPkg: Record<string, any> = {};
   const fields = [
     'name',
@@ -360,14 +363,8 @@ function rewritePackageJson(pkg: Record<string, any>, typesOnly: boolean) {
 
   const distDirStr = `${DIST_DIR}/`;
 
-  if (typesOnly) {
-    newPkg.main = '';
-    delete newPkg.module;
-    delete newPkg.type;
-  } else {
-    newPkg.main = newPkg.main.replace(distDirStr, '');
-    newPkg.module = newPkg.module.replace(distDirStr, '');
-  }
+  newPkg.main = newPkg.main.replace(distDirStr, '');
+  newPkg.module = newPkg.module.replace(distDirStr, '');
   newPkg.typings = newPkg.typings.replace(distDirStr, '');
   newPkg.typescript = {
     definition: newPkg.typescript.definition.replace(distDirStr, ''),
@@ -376,7 +373,7 @@ function rewritePackageJson(pkg: Record<string, any>, typesOnly: boolean) {
   if (!pkg.exports) {
     newPkg.exports = presetFields.exports;
   }
-  newPkg.exports = rewriteExports(pkg.exports, DIST_DIR, typesOnly);
+  newPkg.exports = rewriteExports(pkg.exports, DIST_DIR);
 
   if (pkg.bin) {
     newPkg.bin = {};
@@ -392,7 +389,6 @@ function rewritePackageJson(pkg: Record<string, any>, typesOnly: boolean) {
 export function validatePackageJson(
   pkg: any,
   opts: {
-    typesOnly: boolean;
     includesCommonJS: boolean;
   },
 ) {
@@ -407,19 +403,6 @@ export function validatePackageJson(
     );
   }
 
-  // Type only packages have simpler rules (following the style of https://github.com/DefinitelyTyped/DefinitelyTyped packages)
-  if (opts.typesOnly) {
-    expect('main', '');
-    expect('module', undefined);
-    expect('typings', presetFields.typings);
-    expect('typescript.definition', presetFields.typescript.definition);
-    expect("exports['.'].default", {
-      // only the "types" field is required
-      types: presetFields.exports['.'].default.types,
-    });
-    return;
-  }
-
   // If the package has NO binary we need to check the exports map.
   // a package should either
   // 1. have a bin property

src/commands/check.ts

@@ -28,19 +28,6 @@ const ExportsMapModel = zod.record(
   ]),
 );
 
-const TypesOnlyExportsMapEntry = zod.object({
-  types: zod.string(),
-});
-
-const TypesOnlyExportsMapModel = zod.record(
-  zod.union([
-    zod.string(),
-    zod.object({
-      default: TypesOnlyExportsMapEntry,
-    }),
-  ]),
-);
-
 const BinModel = zod.record(zod.string());
 
 export const checkCommand = createCommand<{}, {}>(api => {
@@ -105,9 +92,6 @@ export const checkCommand = createCommand<{}, {}>(api => {
                 packageJSON: distPackageJSON,
                 skipExports: new Set<string>(config?.check?.skip ?? []),
                 includesCommonJS: config?.commonjs ?? true,
-                // a tell for a types-only build is the lack of main import and presence of typings
-                typesOnly:
-                  distPackageJSON.main === '' && (distPackageJSON.typings || '').endsWith('d.ts'),
               });
             } catch (err) {
               api.reporter.error(`Integrity check of '${packageJSON.name}' failed.`);
@@ -135,39 +119,17 @@ async function checkExportsMapIntegrity(args: {
   };
   skipExports: Set<string>;
   includesCommonJS: boolean;
-  typesOnly: boolean;
 }) {
-  const exportsMapResult = (args.typesOnly ? TypesOnlyExportsMapModel : ExportsMapModel).safeParse(
-    args.packageJSON['exports'],
-  );
+  const exportsMapResult = ExportsMapModel.safeParse(args.packageJSON['exports']);
   if (exportsMapResult.success === false) {
     throw new Error(
       "Missing exports map within the 'package.json'.\n" +
         exportsMapResult.error.message +
         '\nCorrect Example:\n' +
-        JSON.stringify(
-          args.typesOnly
-            ? {
-                ...presetFields.exports,
-                '.': {
-                  default: {
-                    types: presetFields.exports['.'].default.types,
-                  },
-                },
-              }
-            : presetFields.exports,
-          null,
-          2,
-        ),
+        JSON.stringify(presetFields.exports, null, 2),
     );
   }
 
-  // just check if the types under default exist
-  if (args.typesOnly) {
-    await fse.stat(path.join(args.cwd, (args.packageJSON.exports as any)?.['.']?.default?.types));
-    return;
-  }
-
   const exportsMap = exportsMapResult['data'];
 
   const cjsSkipExports = new Set<string>();

src/utils/rewrite-exports.ts

@@ -6,11 +6,7 @@ type Exports =
       default?: string | Record<string, string>;
     };
 
-export function rewriteExports(
-  exports: Record<string, Exports>,
-  distDir: string,
-  typesOnly: boolean,
-) {
+export function rewriteExports(exports: Record<string, Exports>, distDir: string) {
   const newExports = { ...exports };
 
   for (const [key, value] of Object.entries(newExports)) {
@@ -28,24 +24,17 @@ export function rewriteExports(
         if (typeof value === 'object') {
           const newValue: Record<string, string> = {};
           for (const [key, path] of Object.entries(value)) {
-            if (!typesOnly || key === 'types') {
-              // types-only builds need just the types field
-              newValue[key] = path.replace(`${distDir}/`, '');
-            }
+            newValue[key] = path.replace(`${distDir}/`, '');
           }
           return newValue;
         }
         return value.replace(`${distDir}/`, '');
       }
 
       newValue = {
-        ...(typesOnly
-          ? {}
-          : {
-              require: transformValue(newValue.require),
-              import: transformValue(newValue.import),
-            }),
-        default: transformValue(typesOnly ? newValue.default : newValue.import),
+        require: transformValue(newValue.require),
+        import: transformValue(newValue.import),
+        default: transformValue(newValue.import),
       };
     }
     newExports[key.replace(`${distDir}/`, '')] = newValue;

test/__fixtures__/simple-monorepo-pnpm/packages/c/package.json

@@ -1,10 +1,20 @@
 {
   "name": "c",
-  "main": "",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
+      "require": {
+        "types": "./dist/typings/index.d.cts",
+        "default": "./dist/cjs/index.js"
+      },
+      "import": {
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
       "default": {
-        "types": "./dist/typings/index.d.ts"
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
       }
     },
     "./package.json": "./package.json"

test/__fixtures__/simple-monorepo/packages/c/package.json

@@ -1,10 +1,20 @@
 {
   "name": "c",
-  "main": "",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
+      "require": {
+        "types": "./dist/typings/index.d.cts",
+        "default": "./dist/cjs/index.js"
+      },
+      "import": {
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
       "default": {
-        "types": "./dist/typings/index.d.ts"
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
       }
     },
     "./package.json": "./package.json"

test/__fixtures__/simple-types-only/package.json

@@ -1,11 +1,21 @@
 {
   "name": "simple-types-only",
   "type": "module",
-  "main": "",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
+      "require": {
+        "types": "./dist/typings/index.d.cts",
+        "default": "./dist/cjs/index.js"
+      },
+      "import": {
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
       "default": {
-        "types": "./dist/typings/index.d.ts"
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
       }
     },
     "./package.json": "./package.json"