@nx/rollup 0.0.0-pr-22179-271588f

package/src/generators/configuration/schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxRollupProject",
+  "cli": "nx",
+  "title": "Add Rollup Configuration to a project",
+  "description": "Add Rollup Configuration to a project.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-dropdown": "project",
+      "x-prompt": "What is the name of the project to set up a rollup for?",
+      "x-priority": "important"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["babel", "swc", "tsc"],
+      "description": "The compiler to use to build source.",
+      "default": "babel"
+    },
+    "main": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the main entry file. Defaults to '<projectRoot>/src/main.ts'.",
+      "alias": "entryFile",
+      "x-priority": "important"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the tsconfig file to build with. Defaults to '<projectRoot>/tsconfig.app.json'.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "skipValidation": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not perform any validation on existing project.",
+      "x-priority": "internal"
+    },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used to import it, like `@myorg/my-awesome-lib`."
+    },
+    "external": {
+      "type": "array",
+      "description": "A list of external modules that will not be bundled (`react`, `react-dom`, etc.).",
+      "items": {
+        "type": "string"
+      }
+    },
+    "rollupConfig": {
+      "type": "string",
+      "description": "Path relative to workspace root to a custom rollup file that takes a config object and returns an updated config."
+    },
+    "buildTarget": {
+      "description": "The build target to add.",
+      "type": "string",
+      "default": "build"
+    },
+    "format": {
+      "description": "The format to build the library (esm or cjs).",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["esm", "cjs"]
+      },
+      "default": ["esm"]
+    }
+  },
+  "required": []
+}

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

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function rollupInitGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default rollupInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,44 @@
+"use strict";
+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);
+    }
+    return task;
+}
+exports.rollupInitGenerator = rollupInitGenerator;
+exports.default = rollupInitGenerator;

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

@@ -0,0 +1,7 @@
+export interface Schema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWebpackInit",
+  "cli": "nx",
+  "title": "Init Webpack Plugin",
+  "description": "Init Webpack Plugin.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "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/migrations/update-15-0-0/add-babel-inputs.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-0-0/add-babel-inputs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const add_babel_inputs_1 = require("@nx/js/src/utils/add-babel-inputs");
+async function default_1(tree) {
+    (0, add_babel_inputs_1.addBabelInputs)(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/rollup', '@nx/rollup');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (options, projectName, targetName, _configurationName) => {
+        if (options.babelUpwardRootMode !== undefined) {
+            return;
+        }
+        const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        projectConfiguration.targets[targetName].options.babelUpwardRootMode =
+            true;
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executors = new Set(['@nx/rollup:rollup', '@nrwl/rollup:rollup']);
+async function default_1(tree) {
+    // use project graph to get the expanded target configurations
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    for (const [projectName, { data: projectData }] of Object.entries(projectGraph.nodes)) {
+        if (projectData.projectType !== 'library') {
+            continue;
+        }
+        for (const [targetName, target] of Object.entries(projectData.targets || {})) {
+            if (!executors.has(target.executor)) {
+                continue;
+            }
+            if (!target.options ||
+                target.options.updateBuildableProjectDepsInPackageJson === undefined) {
+                // read the project configuration to write the explicit project configuration
+                // and avoid writing the expanded target configuration
+                const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+                project.targets[targetName].options ??= {};
+                project.targets[targetName].options.updateBuildableProjectDepsInPackageJson = true;
+                (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+            }
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

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;
+}

package/src/utils/ensure-dependencies.d.ts

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type EnsureDependenciesOptions = {
+    compiler?: 'babel' | 'swc' | 'tsc';
+};
+export declare function ensureDependencies(tree: Tree, options: EnsureDependenciesOptions): GeneratorCallback;

package/src/utils/ensure-dependencies.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("@nx/js/src/utils/versions");
+const versions_2 = require("./versions");
+function ensureDependencies(tree, options) {
+    if (options.compiler === 'swc') {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@swc/helpers': versions_1.swcHelpersVersion,
+            '@swc/core': versions_1.swcCoreVersion,
+            'swc-loader': versions_2.swcLoaderVersion,
+        });
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { tslib: versions_2.tsLibVersion });
+}
+exports.ensureDependencies = ensureDependencies;

package/src/utils/fs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+export declare function deleteOutputDir(root: string, outputPath: string): void;

package/src/utils/fs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOutputDir = void 0;
+const path = require("path");
+const fs_1 = require("fs");
+/**
+ * Delete an output directory, but error out if it's the root of the project.
+ */
+function deleteOutputDir(root, outputPath) {
+    const resolvedOutputPath = path.resolve(root, outputPath);
+    if (resolvedOutputPath === root) {
+        throw new Error('Output path MUST not be project root directory!');
+    }
+    (0, fs_1.rmSync)(resolvedOutputPath, { recursive: true, force: true });
+}
+exports.deleteOutputDir = deleteOutputDir;

package/src/utils/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const nxVersion: any;
+export declare const swcLoaderVersion = "0.1.15";
+export declare const tsLibVersion = "^2.3.0";

package/src/utils/versions.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.swcLoaderVersion = '0.1.15';
+exports.tsLibVersion = '^2.3.0';