@nx/rollup 16.6.0-beta.6 → 16.6.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "16.6.0-beta.6",
+  "version": "16.6.0-beta.8",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -29,9 +29,9 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nrwl/rollup": "16.6.0-beta.6",
-    "@nx/devkit": "16.6.0-beta.6",
-    "@nx/js": "16.6.0-beta.6",
+    "@nrwl/rollup": "16.6.0-beta.8",
+    "@nx/devkit": "16.6.0-beta.8",
+    "@nx/js": "16.6.0-beta.8",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-commonjs": "^20.0.0",
     "@rollup/plugin-image": "^2.1.0",
@@ -41,6 +41,7 @@
     "babel-plugin-transform-async-to-promises": "^0.8.15",
     "chalk": "^4.1.0",
     "dotenv": "~10.0.0",
+    "fast-glob": "^3.2.7",
     "postcss": "^8.4.14",
     "rollup": "^2.56.2",
     "rollup-plugin-copy": "^3.4.0",
@@ -54,5 +55,5 @@
     "access": "public"
   },
   "types": "./index.d.ts",
-  "gitHead": "9aad21dbfb2b659e488b6626f59df58ab23c0032"
+  "gitHead": "d1d06349e703d903ac47fb7adc7d250ce140d77e"
 }

package/src/executors/rollup/lib/normalize.d.ts

@@ -1,3 +1,4 @@
+import { ExecutorContext } from '@nx/devkit';
 import type { AssetGlobPattern, RollupExecutorOptions } from '../schema';
 export interface NormalizedRollupExecutorOptions extends RollupExecutorOptions {
     entryRoot: string;
@@ -5,6 +6,6 @@ export interface NormalizedRollupExecutorOptions extends RollupExecutorOptions {
     assets: AssetGlobPattern[];
     rollupConfig: string[];
 }
-export declare function normalizeRollupExecutorOptions(options: RollupExecutorOptions, root: string, sourceRoot: string): NormalizedRollupExecutorOptions;
+export declare function normalizeRollupExecutorOptions(options: RollupExecutorOptions, context: ExecutorContext, sourceRoot: string): NormalizedRollupExecutorOptions;
 export declare function normalizePluginPath(pluginPath: void | string, root: string): string;
 export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string): AssetGlobPattern[];

package/src/executors/rollup/lib/normalize.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeAssets = exports.normalizePluginPath = exports.normalizeRollupExecutorOptions = void 0;
 const path_1 = require("path");
+const fast_glob_1 = require("fast-glob");
 const fs_1 = require("fs");
 const devkit_1 = require("@nx/devkit");
-function normalizeRollupExecutorOptions(options, root, sourceRoot) {
+function normalizeRollupExecutorOptions(options, context, sourceRoot) {
+    const { root } = context;
     const main = `${root}/${options.main}`;
     const entryRoot = (0, path_1.dirname)(main);
     const project = options.project
@@ -26,7 +28,7 @@ function normalizeRollupExecutorOptions(options, root, sourceRoot) {
         entryRoot,
         project,
         projectRoot,
-        outputPath, skipTypeCheck: options.skipTypeCheck || false });
+        outputPath, skipTypeCheck: options.skipTypeCheck || false, additionalEntryPoints: createEntryPoints(options, context) });
 }
 exports.normalizeRollupExecutorOptions = normalizeRollupExecutorOptions;
 function normalizePluginPath(pluginPath, root) {
@@ -75,3 +77,11 @@ function normalizeAssets(assets, root, sourceRoot) {
     });
 }
 exports.normalizeAssets = normalizeAssets;
+function createEntryPoints(options, context) {
+    var _a;
+    if (!((_a = options.additionalEntryPoints) === null || _a === void 0 ? void 0 : _a.length))
+        return [];
+    return (0, fast_glob_1.sync)(options.additionalEntryPoints, {
+        cwd: context.root,
+    });
+}

package/src/executors/rollup/lib/update-package-json.js

@@ -4,37 +4,48 @@ exports.updatePackageJson = void 0;
 const path_1 = require("path");
 const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
 const fileutils_1 = require("nx/src/utils/fileutils");
+// TODO(jack): Use updatePackageJson from @nx/js instead.
 function updatePackageJson(options, context, target, dependencies, packageJson) {
+    var _a, _b;
+    var _c;
     const hasEsmFormat = options.format.includes('esm');
     const hasCjsFormat = options.format.includes('cjs');
-    const types = `./${(0, path_1.relative)(options.projectRoot, options.main).replace(/\.[jt]sx?$/, '.d.ts')}`;
-    const exports = {
-        // TS 4.5+
-        '.': {
-            types,
-        },
-    };
+    if (options.generateExportsField) {
+        packageJson.exports =
+            typeof packageJson.exports === 'string' ? {} : Object.assign({}, packageJson.exports);
+        packageJson.exports['./package.json'] = './package.json';
+    }
     if (hasEsmFormat) {
-        // `module` field is used by bundlers like rollup and webpack to detect ESM.
-        // May not be required in the future if type is already "module".
-        packageJson.module = './index.js';
-        exports['.']['import'] = './index.js';
+        const esmExports = getExports(Object.assign(Object.assign({}, options), { fileExt: '.esm.js' }));
+        packageJson.module = esmExports['.'];
         if (!hasCjsFormat) {
-            packageJson.main = './index.js';
+            packageJson.type = 'module';
+            (_a = packageJson.main) !== null && _a !== void 0 ? _a : (packageJson.main = esmExports['.']);
+        }
+        if (options.generateExportsField) {
+            for (const [exportEntry, filePath] of Object.entries(esmExports)) {
+                packageJson.exports[exportEntry] = hasCjsFormat
+                    ? { import: filePath }
+                    : filePath;
+            }
         }
     }
     if (hasCjsFormat) {
-        packageJson.main = './index.cjs';
-        exports['.']['require'] = './index.cjs';
-    }
-    if (!options.skipTypeField) {
-        packageJson.type = options.format.includes('esm') ? 'module' : 'commonjs';
-    }
-    // Support for older TS versions < 4.5
-    packageJson.types = types;
-    // TODO(jack): remove this for Nx 16
-    if (options.generateExportsField && typeof packageJson.exports !== 'string') {
-        packageJson.exports = Object.assign(Object.assign({}, packageJson.exports), exports);
+        const cjsExports = getExports(Object.assign(Object.assign({}, options), { fileExt: '.cjs.js' }));
+        packageJson.main = cjsExports['.'];
+        if (!hasEsmFormat) {
+            packageJson.type = 'commonjs';
+        }
+        if (options.generateExportsField) {
+            for (const [exportEntry, filePath] of Object.entries(cjsExports)) {
+                if (hasEsmFormat) {
+                    (_b = (_c = packageJson.exports[exportEntry])['default']) !== null && _b !== void 0 ? _b : (_c['default'] = filePath);
+                }
+                else {
+                    packageJson.exports[exportEntry] = filePath;
+                }
+            }
+        }
     }
     (0, fileutils_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
     if (dependencies.length > 0 &&
@@ -43,3 +54,18 @@ function updatePackageJson(options, context, target, dependencies, packageJson)
     }
 }
 exports.updatePackageJson = updatePackageJson;
+function getExports(options) {
+    const mainFile = options.outputFileName
+        ? options.outputFileName.replace(/\.[tj]s$/, '')
+        : (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
+    const exports = {
+        '.': './' + mainFile + options.fileExt,
+    };
+    if (options.additionalEntryPoints) {
+        for (const file of options.additionalEntryPoints) {
+            const { name: fileName } = (0, path_1.parse)(file);
+            exports['./' + fileName] = './' + fileName + options.fileExt;
+        }
+    }
+    return exports;
+}

package/src/executors/rollup/rollup.impl.js

@@ -20,8 +20,8 @@ const normalize_1 = require("./lib/normalize");
 const analyze_plugin_1 = require("./lib/analyze-plugin");
 const fs_1 = require("../../utils/fs");
 const swc_plugin_1 = require("./lib/swc-plugin");
-const validate_types_1 = require("./lib/validate-types");
 const update_package_json_1 = require("./lib/update-package-json");
+const type_definitions_1 = require("@nx/js/src/plugins/rollup/type-definitions");
 // These use require because the ES import isn't correct.
 const commonjs = require('@rollup/plugin-commonjs');
 const image = require('@rollup/plugin-image');
@@ -37,25 +37,13 @@ function rollupExecutor(rawOptions, context) {
         const project = context.projectsConfigurations.projects[context.projectName];
         const sourceRoot = project.sourceRoot;
         const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
-        const options = (0, normalize_1.normalizeRollupExecutorOptions)(rawOptions, context.root, sourceRoot);
+        const options = (0, normalize_1.normalizeRollupExecutorOptions)(rawOptions, context, sourceRoot);
         const packageJson = (0, devkit_1.readJsonFile)(options.project);
         const npmDeps = ((_b = context.projectGraph.dependencies[context.projectName]) !== null && _b !== void 0 ? _b : [])
             .filter((d) => d.target.startsWith('npm:'))
             .map((d) => d.target.slice(4));
         const rollupOptions = createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
         const outfile = resolveOutfile(context, options);
-        if (options.compiler === 'swc') {
-            try {
-                yield tslib_1.__await((0, validate_types_1.validateTypes)({
-                    workspaceRoot: context.root,
-                    projectRoot: options.projectRoot,
-                    tsconfig: options.tsConfig,
-                }));
-            }
-            catch (_d) {
-                return yield tslib_1.__await({ success: false });
-            }
-        }
         if (options.watch) {
             const watcher = rollup.watch(rollupOptions);
             return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, rxjs_for_await_1.eachValueFrom)(new rxjs_1.Observable((obs) => {
@@ -122,13 +110,16 @@ function createRollupOptions(options, dependencies, context, packageJson, source
         options.format = readCompatibleFormats(config);
     }
     return options.format.map((format, idx) => {
+        // Either we're generating only one format, so we should bundle types
+        // OR we are generating dual formats, so only bundle types for CJS.
+        const shouldBundleTypes = options.format.length === 1 || format === 'cjs';
         const plugins = [
             copy({
                 targets: convertCopyAssetsToRollupOptions(options.outputPath, options.assets),
             }),
             image(),
             json(),
-            (useTsc || useBabel) &&
+            (useTsc || shouldBundleTypes) &&
                 require('rollup-plugin-typescript2')({
                     check: !options.skipTypeCheck,
                     tsconfig: options.tsConfig,
@@ -136,6 +127,11 @@ function createRollupOptions(options, dependencies, context, packageJson, source
                         compilerOptions: createTsCompilerOptions(config, dependencies, options),
                     },
                 }),
+            shouldBundleTypes &&
+                (0, type_definitions_1.typeDefinitions)({
+                    main: options.main,
+                    projectRoot: options.projectRoot,
+                }),
             peerDepsExternal({
                 packageJsonPath: options.project,
             }),
@@ -195,18 +191,20 @@ function createRollupOptions(options, dependencies, context, packageJson, source
             externalPackages = externalPackages.concat(options.external);
         }
         externalPackages = [...new Set(externalPackages)];
+        const mainEntryFileName = options.outputFileName || options.main;
+        const input = {};
+        input[(0, path_1.parse)(mainEntryFileName).name] = options.main;
+        options.additionalEntryPoints.forEach((entry) => {
+            input[(0, path_1.parse)(entry).name] = entry;
+        });
         const rollupConfig = {
-            input: options.outputFileName
-                ? {
-                    [(0, path_1.parse)(options.outputFileName).name]: options.main,
-                }
-                : options.main,
+            input,
             output: {
                 format,
                 dir: `${options.outputPath}`,
                 name: (0, devkit_1.names)(context.projectName).className,
-                entryFileNames: `[name].${format === 'esm' ? 'js' : 'cjs'}`,
-                chunkFileNames: `[name].${format === 'esm' ? 'js' : 'cjs'}`,
+                entryFileNames: `[name].${format}.js`,
+                chunkFileNames: `[name].${format}.js`,
             },
             external: (id) => {
                 return externalPackages.some((name) => id === name || id.startsWith(`${name}/`)); // Could be a deep import
@@ -230,6 +228,9 @@ function createTsCompilerOptions(config, dependencies, options) {
     if (config.options.module === ts.ModuleKind.CommonJS) {
         compilerOptions['module'] = 'ESNext';
     }
+    if (options.compiler === 'swc') {
+        compilerOptions['emitDeclarationOnly'] = true;
+    }
     return compilerOptions;
 }
 function convertCopyAssetsToRollupOptions(outputPath, assets) {
@@ -255,6 +256,6 @@ function resolveOutfile(context, options) {
     if (!((_a = options.format) === null || _a === void 0 ? void 0 : _a.includes('cjs')))
         return undefined;
     const { name } = (0, path_1.parse)((_b = options.outputFileName) !== null && _b !== void 0 ? _b : options.main);
-    return (0, path_1.resolve)(context.root, options.outputPath, `${name}.cjs`);
+    return (0, path_1.resolve)(context.root, options.outputPath, `${name}.cjs.js`);
 }
 exports.default = rollupExecutor;

package/src/executors/rollup/schema.d.ts

@@ -37,10 +37,11 @@ export interface RollupExecutorOptions {
    */
   buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
   deleteOutputPath?: boolean;
-  format?: string[];
+  format?: ('cjs' | 'esm')[];
   compiler?: 'babel' | 'tsc' | 'swc';
   javascriptEnabled?: boolean;
   generateExportsField?: boolean;
+  additionalEntryPoints?: string[];
   skipTypeCheck?: boolean;
   babelUpwardRootMode?: boolean;
   skipTypeField?: boolean;

package/src/executors/rollup/schema.json

@@ -138,8 +138,18 @@
     },
     "generateExportsField": {
       "type": "boolean",
-      "description": "Generate package.json with 'exports' field. This field defines entry points in the package and is used by Node and the TypeScript compiler.",
-      "default": false
+      "alias": "exports",
+      "description": "Update the output package.json file's 'exports' field. This field is used by Node and bundles.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "description": "Additional entry-points to add to exports field in the package.json file.",
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
     },
     "skipTypeCheck": {
       "type": "boolean",

package/src/generators/configuration/configuration.js

@@ -40,7 +40,7 @@ function addBuildTarget(tree, options) {
     const tsConfig = (_a = options.tsConfig) !== null && _a !== void 0 ? _a : (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json');
     const buildOptions = {
         main: (_b = options.main) !== null && _b !== void 0 ? _b : (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts'),
-        outputPath: (0, devkit_1.joinPathFragments)('dist', project.root),
+        outputPath: (0, devkit_1.joinPathFragments)('dist', project.root === '.' ? project.name : project.root),
         compiler: (_c = options.compiler) !== null && _c !== void 0 ? _c : 'babel',
         tsConfig,
         project: `${project.root}/package.json`,

package/src/executors/rollup/lib/validate-types.d.ts

@@ -1,5 +0,0 @@
-export declare function validateTypes(opts: {
-    workspaceRoot: string;
-    projectRoot: string;
-    tsconfig: string;
-}): Promise<void>;

package/src/executors/rollup/lib/validate-types.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTypes = void 0;
-const tslib_1 = require("tslib");
-const js_1 = require("@nx/js");
-const path_1 = require("path");
-function validateTypes(opts) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const result = yield (0, js_1.runTypeCheck)({
-            workspaceRoot: opts.workspaceRoot,
-            tsConfigPath: (0, path_1.join)(opts.workspaceRoot, opts.tsconfig),
-            mode: 'noEmit',
-        });
-        yield (0, js_1.printDiagnostics)(result.errors, result.warnings);
-        if (result.errors.length > 0) {
-            throw new Error('Found type errors. See above.');
-        }
-    });
-}
-exports.validateTypes = validateTypes;