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

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2023 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Monorepos · Fast CI
+
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+
+This package is a [Rollup plugin for Nx](https://nx.dev/packages/rollup).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+

package/executors.json

@@ -0,0 +1,9 @@
+{
+  "executors": {
+    "rollup": {
+      "implementation": "./src/executors/rollup/rollup.impl",
+      "schema": "./src/executors/rollup/schema.json",
+      "description": "Bundle a package using Rollup."
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,19 @@
+{
+  "name": "Nx rollup",
+  "version": "0.1",
+  "generators": {
+    "init": {
+      "factory": "./src/generators/init/init#rollupInitGenerator",
+      "schema": "./src/generators/init/schema.json",
+      "description": "Initialize the `@nrwl/rollup` plugin.",
+      "aliases": ["ng-add"],
+      "hidden": true
+    },
+    "configuration": {
+      "aliases": ["rollup-project"],
+      "factory": "./src/generators/configuration/configuration",
+      "schema": "./src/generators/configuration/schema.json",
+      "description": "Add rollup configuration to a project."
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1,7 @@
+import { configurationGenerator } from './src/generators/configuration/configuration';
+export { configurationGenerator };
+/** @deprecated Use `configurationGenerator` instead. */
+export declare const rollupProjectGenerator: typeof configurationGenerator;
+export * from './src/generators/init/init';
+export type { AssetGlobPattern, Globals, RollupExecutorOptions, } from './src/executors/rollup/schema';
+export * from './src/executors/rollup/rollup.impl';

package/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollupProjectGenerator = exports.configurationGenerator = void 0;
+const tslib_1 = require("tslib");
+const configuration_1 = require("./src/generators/configuration/configuration");
+Object.defineProperty(exports, "configurationGenerator", { enumerable: true, get: function () { return configuration_1.configurationGenerator; } });
+// Exported for backwards compatibility in case a plugin is using the old name.
+/** @deprecated Use `configurationGenerator` instead. */
+exports.rollupProjectGenerator = configuration_1.configurationGenerator;
+tslib_1.__exportStar(require("./src/generators/init/init"), exports);
+tslib_1.__exportStar(require("./src/executors/rollup/rollup.impl"), exports);

package/migrations.json

@@ -0,0 +1,29 @@
+{
+  "generators": {
+    "add-babel-inputs": {
+      "cli": "nx",
+      "version": "15.0.0-beta.0",
+      "description": "Adds babel.config.json to the hash of all tasks",
+      "factory": "./src/migrations/update-15-0-0/add-babel-inputs"
+    },
+    "update-16-0-0-add-nx-packages": {
+      "cli": "nx",
+      "version": "16.0.0-beta.1",
+      "description": "Replace @nrwl/rollup with @nx/rollup",
+      "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
+    },
+    "update-16-3-3-add-babel-upward-root-mode-flag": {
+      "cli": "nx",
+      "version": "16.3.3-beta.0",
+      "description": "Add babelUpwardRootMode if not already defined",
+      "implementation": "./src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag"
+    },
+    "explicitly-set-projects-to-update-buildable-deps": {
+      "cli": "nx",
+      "version": "16.6.0-beta.0",
+      "description": "Explicitly set 'updateBuildableProjectDepsInPackageJson' to 'true' in targets that rely on that value as the default.",
+      "factory": "./src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps"
+    }
+  },
+  "packageJsonUpdates": {}
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@nx/rollup",
+  "version": "0.0.0-pr-22179-271588f",
+  "private": false,
+  "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/rollup"
+  },
+  "keywords": [
+    "Monorepo",
+    "Rollup",
+    "Web",
+    "CLI"
+  ],
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "homepage": "https://nx.dev",
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "ng-update": {
+    "requirements": {},
+    "migrations": "./migrations.json"
+  },
+  "dependencies": {
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^20.0.0",
+    "@rollup/plugin-image": "^2.1.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.4",
+    "autoprefixer": "^10.4.9",
+    "babel-plugin-transform-async-to-promises": "^0.8.15",
+    "chalk": "^4.1.0",
+    "postcss": "^8.4.14",
+    "rollup": "^2.56.2",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-postcss": "^4.0.1",
+    "rollup-plugin-typescript2": "0.36.0",
+    "rxjs": "^7.8.0",
+    "tslib": "^2.3.0",
+    "@nx/devkit": "0.0.0-pr-22179-271588f",
+    "@nx/js": "0.0.0-pr-22179-271588f",
+    "@nrwl/rollup": "0.0.0-pr-22179-271588f"
+  },
+  "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/lib/analyze-plugin.d.ts

@@ -0,0 +1,4 @@
+export declare function analyze(): {
+    name: string;
+    renderChunk(source: any, chunk: any): void;
+};

package/src/executors/rollup/lib/analyze-plugin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyze = void 0;
+const chalk = require("chalk");
+const devkit_1 = require("@nx/devkit");
+const formatBytes = (bytes) => {
+    if (bytes === 0)
+        return '0 Byte';
+    const k = 1000;
+    const dm = 3;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+};
+function analyze() {
+    return {
+        name: 'rollup-plugin-nx-analyzer',
+        renderChunk(source, chunk) {
+            const sourceBytes = formatBytes(source.length);
+            const fileName = chunk.fileName;
+            devkit_1.logger.info(`  ${chalk.bold(fileName)} ${chalk.cyan(sourceBytes)}`);
+        },
+    };
+}
+exports.analyze = analyze;

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

@@ -0,0 +1,11 @@
+import { ExecutorContext } from '@nx/devkit';
+import type { AssetGlobPattern, RollupExecutorOptions } from '../schema';
+export interface NormalizedRollupExecutorOptions extends RollupExecutorOptions {
+    entryRoot: string;
+    projectRoot: string;
+    assets: AssetGlobPattern[];
+    rollupConfig: string[];
+}
+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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAssets = exports.normalizePluginPath = exports.normalizeRollupExecutorOptions = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+function normalizeRollupExecutorOptions(options, context, sourceRoot) {
+    const { root } = context;
+    const main = `${root}/${options.main}`;
+    const entryRoot = (0, path_1.dirname)(main);
+    const project = options.project
+        ? `${root}/${options.project}`
+        : (0, path_1.join)(root, 'package.json');
+    const projectRoot = (0, path_1.dirname)(project);
+    const outputPath = `${root}/${options.outputPath}`;
+    return {
+        ...options,
+        // de-dupe formats
+        format: Array.from(new Set(options.format)),
+        rollupConfig: []
+            .concat(options.rollupConfig)
+            .filter(Boolean)
+            .map((p) => normalizePluginPath(p, root)),
+        assets: options.assets
+            ? normalizeAssets(options.assets, root, sourceRoot)
+            : undefined,
+        main,
+        entryRoot,
+        project,
+        projectRoot,
+        outputPath,
+        skipTypeCheck: options.skipTypeCheck || false,
+        additionalEntryPoints: (0, js_1.createEntryPoints)(options.additionalEntryPoints, context.root),
+    };
+}
+exports.normalizeRollupExecutorOptions = normalizeRollupExecutorOptions;
+function normalizePluginPath(pluginPath, root) {
+    if (!pluginPath) {
+        return '';
+    }
+    try {
+        return require.resolve(pluginPath);
+    }
+    catch {
+        return (0, path_1.resolve)(root, pluginPath);
+    }
+}
+exports.normalizePluginPath = normalizePluginPath;
+function normalizeAssets(assets, root, sourceRoot) {
+    return assets.map((asset) => {
+        if (typeof asset === 'string') {
+            const assetPath = (0, devkit_1.normalizePath)(asset);
+            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
+            const resolvedSourceRoot = (0, path_1.resolve)(root, sourceRoot);
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new Error(`The ${resolvedAssetPath} asset path must start with the project source root: ${sourceRoot}`);
+            }
+            const isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
+            const input = isDirectory
+                ? resolvedAssetPath
+                : (0, path_1.dirname)(resolvedAssetPath);
+            const output = (0, path_1.relative)(resolvedSourceRoot, (0, path_1.resolve)(root, input));
+            const glob = isDirectory ? '**/*' : (0, path_1.basename)(resolvedAssetPath);
+            return {
+                input,
+                output,
+                glob,
+            };
+        }
+        else {
+            if (asset.output.startsWith('..')) {
+                throw new Error('An asset cannot be written to a location outside of the output path.');
+            }
+            const assetPath = (0, devkit_1.normalizePath)(asset.input);
+            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
+            return {
+                ...asset,
+                input: resolvedAssetPath,
+                // Now we remove starting slash to make Webpack place it from the output root.
+                output: asset.output.replace(/^\//, ''),
+            };
+        }
+    });
+}
+exports.normalizeAssets = normalizeAssets;

package/src/executors/rollup/lib/run-rollup.d.ts

@@ -0,0 +1,4 @@
+import * as rollup from 'rollup';
+export declare function runRollup(options: rollup.RollupOptions): import("rxjs").Observable<{
+    success: boolean;
+}>;

package/src/executors/rollup/lib/run-rollup.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRollup = void 0;
+const rollup = require("rollup");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+function runRollup(options) {
+    return (0, rxjs_1.from)(rollup.rollup(options)).pipe((0, operators_1.switchMap)((bundle) => {
+        const outputOptions = Array.isArray(options.output)
+            ? options.output
+            : [options.output];
+        return (0, rxjs_1.from)(Promise.all(outputOptions.map((o) => bundle.write(o))));
+    }), (0, operators_1.map)(() => ({ success: true })));
+}
+exports.runRollup = runRollup;

package/src/executors/rollup/lib/swc-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'rollup';
+export declare function swc(): Plugin;

package/src/executors/rollup/lib/swc-plugin.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swc = void 0;
+function swc() {
+    const { transform } = require('@swc/core');
+    return {
+        name: 'nx-swc',
+        transform(code, filename) {
+            return transform(code, {
+                filename,
+                jsc: {
+                    transform: {
+                        react: { runtime: 'automatic' },
+                    },
+                },
+            });
+        },
+    };
+}
+exports.swc = swc;

package/src/executors/rollup/lib/update-package-json.d.ts

@@ -0,0 +1,3 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+import { NormalizedRollupExecutorOptions } from './normalize';
+export declare function updatePackageJson(options: NormalizedRollupExecutorOptions, packageJson: PackageJson): void;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackageJson = void 0;
+const path_1 = require("path");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+// TODO(jack): Use updatePackageJson from @nx/js instead.
+function updatePackageJson(options, packageJson) {
+    const hasEsmFormat = options.format.includes('esm');
+    const hasCjsFormat = options.format.includes('cjs');
+    if (options.generateExportsField) {
+        packageJson.exports =
+            typeof packageJson.exports === 'string' ? {} : { ...packageJson.exports };
+        packageJson.exports['./package.json'] = './package.json';
+    }
+    if (hasEsmFormat) {
+        const esmExports = getExports({
+            ...options,
+            fileExt: '.esm.js',
+        });
+        packageJson.module = esmExports['.'];
+        if (!hasCjsFormat) {
+            if (!options.skipTypeField)
+                packageJson.type = 'module';
+            packageJson.main ??= esmExports['.'];
+        }
+        if (options.generateExportsField) {
+            for (const [exportEntry, filePath] of Object.entries(esmExports)) {
+                packageJson.exports[exportEntry] = hasCjsFormat
+                    ? // If CJS format is used, make sure `import` (from Node) points to same instance of the package.
+                        // Otherwise, packages that are required to be singletons (like React, RxJS, etc.) will break.
+                        // Reserve `module` entry for bundlers to accommodate tree-shaking.
+                        { [hasCjsFormat ? 'module' : 'import']: filePath }
+                    : filePath;
+            }
+        }
+    }
+    if (hasCjsFormat) {
+        const cjsExports = getExports({
+            ...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) {
+                    // If ESM format used, make sure `import` (from Node) points to a wrapped
+                    // version of CJS file to ensure the package remains a singleton.
+                    // TODO(jack): This can be made into a rollup plugin to re-use in Vite.
+                    const relativeFile = (0, path_1.parse)(filePath).base;
+                    const fauxEsmFilePath = filePath.replace(/\.cjs\.js$/, '.cjs.mjs');
+                    packageJson.exports[exportEntry]['import'] ??= fauxEsmFilePath;
+                    packageJson.exports[exportEntry]['default'] ??= filePath;
+                    // Re-export from relative CJS file, and Node will synthetically export it as ESM.
+                    // Make sure both ESM and CJS point to same instance of the package because libs like React, RxJS, etc. requires it.
+                    // Also need a special .cjs.default.js file that re-exports the `default` from CJS, or else
+                    // default import in Node will not work.
+                    (0, fs_1.writeFileSync)((0, path_1.join)(options.outputPath, filePath.replace(/\.cjs\.js$/, '.cjs.default.js')), `exports._default = require('./${(0, path_1.parse)(filePath).base}').default;`);
+                    (0, fs_1.writeFileSync)((0, path_1.join)(options.outputPath, fauxEsmFilePath), 
+                    // Re-export from relative CJS file, and Node will synthetically export it as ESM.
+                    (0, devkit_1.stripIndents) `
+            export * from './${relativeFile}';
+            export { _default as default } from './${relativeFile.replace(/\.cjs\.js$/, '.cjs.default.js')}';
+            `);
+                }
+                else {
+                    packageJson.exports[exportEntry] = filePath;
+                }
+            }
+        }
+    }
+    (0, fileutils_1.writeJsonFile)(`${options.outputPath}/package.json`, 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.d.ts

@@ -0,0 +1,13 @@
+import * as rollup from 'rollup';
+import type { ExecutorContext } from '@nx/devkit';
+import { DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+import type { PackageJson } from 'nx/src/utils/package-json';
+import { RollupExecutorOptions } from './schema';
+import { NormalizedRollupExecutorOptions } from './lib/normalize';
+export type RollupExecutorEvent = {
+    success: boolean;
+    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[]): Promise<rollup.InputOptions[]>;
+export default rollupExecutor;