@nx/rollup 18.1.0-beta.1 → 18.1.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "18.1.0-beta.1",
+  "version": "18.1.0-beta.3",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -45,12 +45,20 @@
     "rollup-plugin-typescript2": "0.36.0",
     "rxjs": "^7.8.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "18.1.0-beta.1",
-    "@nx/js": "18.1.0-beta.1",
-    "@nrwl/rollup": "18.1.0-beta.1"
+    "@nx/devkit": "18.1.0-beta.3",
+    "@nx/js": "18.1.0-beta.3",
+    "@nrwl/rollup": "18.1.0-beta.3"
   },
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js",
+    "./executors.json": "./executors.json",
+    "./generators.json": "./generators.json",
+    "./migrations.json": "./migrations.json",
+    "./plugin": "./plugin.js"
+  },
   "type": "commonjs"
 }

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, RollupPluginOptions } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });

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

@@ -9,5 +9,5 @@ export type RollupExecutorEvent = {
     outfile?: string;
 };
 export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<RollupExecutorEvent, any, undefined>;
-export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, dependencies: DependentBuildableProjectNode[], context: ExecutorContext, packageJson: PackageJson, sourceRoot: string, npmDeps: string[]): rollup.InputOptions[];
+export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, dependencies: DependentBuildableProjectNode[], context: ExecutorContext, packageJson: PackageJson, sourceRoot: string, npmDeps: string[]): Promise<rollup.InputOptions[]>;
 export default rollupExecutor;

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

@@ -20,6 +20,7 @@ const analyze_plugin_1 = require("./lib/analyze-plugin");
 const fs_1 = require("../../utils/fs");
 const swc_plugin_1 = require("./lib/swc-plugin");
 const update_package_json_1 = require("./lib/update-package-json");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
 // These use require because the ES import isn't correct.
 const commonjs = require('@rollup/plugin-commonjs');
 const image = require('@rollup/plugin-image');
@@ -37,7 +38,7 @@ async function* rollupExecutor(rawOptions, context) {
     const npmDeps = (context.projectGraph.dependencies[context.projectName] ?? [])
         .filter((d) => d.target.startsWith('npm:'))
         .map((d) => d.target.slice(4));
-    const rollupOptions = createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
+    const rollupOptions = await createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
     const outfile = resolveOutfile(context, options);
     if (options.watch) {
         const watcher = rollup.watch(rollupOptions);
@@ -93,7 +94,7 @@ async function* rollupExecutor(rawOptions, context) {
 }
 exports.rollupExecutor = rollupExecutor;
 // -----------------------------------------------------------------------------
-function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
+async function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
     const useBabel = options.compiler === 'babel';
     const useTsc = options.compiler === 'tsc';
     const useSwc = options.compiler === 'swc';
@@ -115,7 +116,7 @@ function createRollupOptions(options, dependencies, context, packageJson, source
         }
         options.format = ['cjs'];
     }
-    return options.format.map((format, idx) => {
+    const _rollupOptions = options.format.map(async (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';
@@ -217,10 +218,31 @@ function createRollupOptions(options, dependencies, context, packageJson, source
             },
             plugins,
         };
-        return options.rollupConfig.reduce((currentConfig, plugin) => {
-            return require(plugin)(currentConfig, options);
-        }, rollupConfig);
+        const userDefinedRollupConfigs = options.rollupConfig.map((plugin) => (0, config_utils_1.loadConfigFile)(plugin));
+        let finalConfig = rollupConfig;
+        for (const _config of userDefinedRollupConfigs) {
+            const config = await _config;
+            if (typeof config === 'function') {
+                finalConfig = config(finalConfig, options);
+            }
+            else {
+                finalConfig = {
+                    ...finalConfig,
+                    ...config,
+                    plugins: [
+                        ...(finalConfig.plugins?.length > 0 ? finalConfig.plugins : []),
+                        ...(config.plugins?.length > 0 ? config.plugins : []),
+                    ],
+                };
+            }
+        }
+        return finalConfig;
     });
+    const rollupOptions = [];
+    for (const rollupOption of _rollupOptions) {
+        rollupOptions.push(await rollupOption);
+    }
+    return rollupOptions;
 }
 exports.createRollupOptions = createRollupOptions;
 function createTsCompilerOptions(config, dependencies, options) {

package/src/generators/init/init.js

@@ -3,11 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollupInitGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../utils/versions");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/rollup/plugin'
+            : plugin.plugin === '@nx/rollup/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/rollup/plugin',
+        options: {
+            buildTargetName: 'build',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
 async function rollupInitGenerator(tree, schema) {
     let task = () => { };
     if (!schema.skipPackageJson) {
         task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/rollup': versions_1.nxVersion }, undefined, schema.keepExistingVersions);
     }
+    schema.addPlugin ??= process.env.NX_ADD_PLUGINS !== 'false';
+    if (schema.addPlugin) {
+        addPlugin(tree);
+    }
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

package/src/generators/init/schema.d.ts

@@ -2,4 +2,6 @@ export interface Schema {
   skipFormat?: boolean;
   skipPackageJson?: boolean;
   keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
 }

package/src/generators/init/schema.json

@@ -21,6 +21,12 @@
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
       "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
     }
   },
   "required": []

package/src/plugins/plugin.d.ts

@@ -0,0 +1,6 @@
+import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;
+export interface RollupPluginOptions {
+    buildTargetName?: string;
+}
+export declare const createNodes: CreateNodes<RollupPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const js_1 = require("@nx/js");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const loadConfigFile = require("rollup/dist/loadConfigFile");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'rollup.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/rollup.config.{js,cjs,mjs}',
+    async (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
+        // Do not create a project if package.json and project.json do not exist
+        const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        options = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildRollupTarget(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildRollupTarget(configFilePath, projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const rollupConfig = (await loadConfigFile((0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath))).options;
+    const outputs = getOutputs(rollupConfig, projectRoot);
+    const targets = {};
+    targets[options.buildTargetName] = {
+        command: `rollup -c ${(0, path_1.basename)(configFilePath)}`,
+        options: { cwd: projectRoot },
+        cache: true,
+        dependsOn: [`^${options.buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        outputs,
+    };
+    return targets;
+}
+function getOutputs(rollupConfigs, projectRoot) {
+    const outputs = new Set();
+    for (const rollupConfig of rollupConfigs) {
+        if (rollupConfig.output) {
+            const rollupConfigOutputs = [];
+            if (Array.isArray(rollupConfig.output)) {
+                rollupConfigOutputs.push(...rollupConfig.output);
+            }
+            else {
+                rollupConfigOutputs.push(rollupConfig.output);
+            }
+            for (const output of rollupConfigOutputs) {
+                const outputPathFromConfig = output.dir
+                    ? output.dir
+                    : output.file
+                        ? (0, path_1.dirname)(output.file)
+                        : 'dist';
+                const outputPath = projectRoot === '.'
+                    ? (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, outputPathFromConfig)
+                    : (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, projectRoot, outputPathFromConfig);
+                outputs.add(outputPath);
+            }
+        }
+    }
+    return Array.from(outputs);
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    return options;
+}