deno-rollup

Next-generation ES module bundler for Deno ported from Rollup.

Table of Contents

• Overview
• Installation
• Documentation
• Plugins
• Examples
• Contributing
• License

Overview

Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application.

This library extends Rollup so that it can be used in Deno - supporting core Deno features out-of-the-box such as URL imports, Typescript and JSX.

Installation

deno-rollup can be used either through a command line interface (CLI) with an optional configuration file, or else through its JavaScript API.

CLI

To install the CLI run:

deno install -f -q --allow-read --allow-write --allow-net --allow-env --unstable https://deno.land/x/drollup@2.50.5+0.18.2/rollup.ts

And follow any suggestions to update your PATH environment variable.

You can then use the CLI to bundle your modules:

# compile to an ESM
rollup main.js --format es --name "myBundle" --file bundle.js

You can also rebuild the bundle when it’s source or config files change on disk using the --watch flag:

# recompile based on `rollup.config.ts` when source files change
rollup -c --watch

JavaScript API

You can import deno-rollup straight into your project to bundle your modules:

import { rollup } from "https://deno.land/x/drollup@2.50.5+0.18.2/mod.ts";

const options = {
  input: "./mod.ts",
  output: {
    dir: "./dist",
    format: "es" as const,
    sourcemap: true,
  },
};

const bundle = await rollup(options);
await bundle.write(options.output);
await bundle.close();

Or using the watch API:

import { watch } from "https://deno.land/x/drollup@2.50.5+0.18.2/mod.ts";

const options = {
  input: "./src/mod.ts",
  output: {
    dir: "./dist",
    format: "es" as const,
    sourcemap: true,
  },
  watch: {
    include: ["src/**"],
  },
};

const watcher = await watch(options);

watcher.on("event", (event) => {
  // event.code can be one of:
  //   START        — the watcher is (re)starting
  //   BUNDLE_START — building an individual bundle
  //                  * event.input will be the input options object if present
  //                  * event.outputFiles cantains an array of the "file" or
  //                    "dir" option values of the generated outputs
  //   BUNDLE_END   — finished building a bundle
  //                  * event.input will be the input options object if present
  //                  * event.outputFiles cantains an array of the "file" or
  //                    "dir" option values of the generated outputs
  //                  * event.duration is the build duration in milliseconds
  //                  * event.result contains the bundle object that can be
  //                    used to generate additional outputs by calling
  //                    bundle.generate or bundle.write. This is especially
  //                    important when the watch.skipWrite option is used.
  //                  You should call "event.result.close()" once you are done
  //                  generating outputs, or if you do not generate outputs.
  //                  This will allow plugins to clean up resources via the
  //                  "closeBundle" hook.
  //   END          — finished building all bundles
  //   ERROR        — encountered an error while bundling
  //                  * event.error contains the error that was thrown
});

// This will make sure that bundles are properly closed after each run
watcher.on("event", (event) => {
  if (event.code === "BUNDLE_END") {
    event.result.close();
  }
});

// stop watching
watcher.close();

Documentation

Please refer to the official Rollup Documentation.

Known deviations from Rollup:

• Deno code support: TypeScript and URL imports supported out-of-the-box.
• CLI does not currently support some nested “dot” flags, namely: --no-treeshake.*, --watch.* and --no-watch.*.
• CLI does not currently support the --plugin flag.
• Some warnings have yet to be implemented.

Where further deviations / incompatibility are found, please raise an issue.

Plugins

A suite of deno-rollup compatible plugins are available in the plugins directory.

Examples

To run the examples you have a couple of options:

Direct from repository

1. Run the deno-rollup helloDeno example directly from the repository:

   deno run --allow-read="./" --allow-write="./dist" --allow-net="deno.land" --allow-env --unstable https://deno.land/x/drollup@2.50.5+0.18.2/examples/helloDeno/rollup.build.ts

   This will create a ./dist directory with the bundled files in your current working directory.

Clone

1. Clone the deno-rollup repo locally:

   git clone git://github.com/cmorten/deno-rollup.git --depth 1
   cd deno-rollup

2. Then enter the desired examples directory and run the build script:

   cd examples/helloDeno
   deno run --allow-read="./" --allow-write="./dist" --allow-net="deno.land" --allow-env --unstable ./rollup.build.ts

   This will create a ./dist directory with the bundled files in the current directory.

3. Further details are available in each example directory.

Contributing

Contributing guide

License

deno-rollup is licensed under the MIT License.

The license for the Rollup library, which this library adapts, is available at ROLLUP_LICENSE.

Derived works other than from Rollup are attributed with their license in source.