Rollup: test case for chaining plugins

.editorconfig

# http://editorconfig.org

root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
max_line_length = 80
indent_style = space
indent_size = 4

[COMMIT_EDITMSG]
trim_trailing_whitespace = false
max_line_length = 72
indent_style = space

.gitignore

/node_modules

/bundle*.js

README.md

test case for chaining Rollup plugins

• npm install downloads dependencies
• npm run prep moves source files into subdirectories in order to work around GitHub Gist restrictions

• npm start performs a one-time compilation, generating bundle.js
• npm run virtual activates the virtual entry point before performing the same compilation, generating bundle_virtual.js

babel.config.js

"use strict";

let TARGETS = "IE 11";

module.exports = {
    presets: [
        ["@babel/preset-env", {
            modules: false,
            targets: TARGETS
        }]
    ]
};

diskless.js

"use strict";

let path = require("path");

let PREFIX = "diskless:";

// `referenceDir` is used for relative imports from diskless modules
// `resolver` is the Rollup plugin responsible for resolving relative imports
// `modules` maps file names to source code
module.exports = (referenceDir, resolver, modules = new Map(), prefix = PREFIX) => ({
    name: "diskless",
    resolveId(importee, importer) {
        if(importer && importer.startsWith(prefix) && /^\.?\.\//.test(importee)) {
            let virtual = path.resolve(referenceDir, importer);
            return resolver.resolveId(importee, virtual);
        }
        return isVirtual(importee, prefix, "resolving") ? importee : null;
    },
    load(id) {
        if(!isVirtual(id, prefix, "loading")) {
            return null;
        }

        let filename = id.substr(prefix.length);
        let source = modules.get(filename);
        if(source === undefined) {
            throw new Error(`missing diskless module: ${filename}`);
        }
        return source;
    },
    register(filename, source) {
        modules.set(filename, source);
    },
    deregister(filename) {
        return modules.delete(filename);
    }
});

function isVirtual(moduleID, prefix, message) {
    let virtual = moduleID.startsWith(prefix);
    console.log(`[DISKLESS] ${message} ${virtual ? "diskless" : "regular"} ` +
            `module \`${moduleID}\``);
    return virtual;
}

index.js

import { log } from "./util";
import noop from "noop";

let generateMessage = () => noop() || "hello world";

log("INFO", generateMessage());

noop.js

let noop = () => {};

export default noop;

package.json

{
    "scripts": {
        "start": "rollup -c rollup.config.js && echo && node bundle.js",
        "virtual": "DISKLESS=1 npm start",
        "prep": "mkdir src && cp index.js util.js src/ && mkdir node_modules/noop && cp noop.js node_modules/noop/index.js"
    },
    "dependencies": {},
    "devDependencies": {
        "@babel/core": "7.1.2",
        "@babel/preset-env": "7.1.0",
        "rollup": "0.66.6",
        "rollup-plugin-babel": "4.0.3",
        "rollup-plugin-node-resolve": "3.4.0"
    }
}

rollup.config.js

"use strict";

let babelConfig = require("./babel.config.js");
let babel = require("rollup-plugin-babel");
let nodeResolve = require("rollup-plugin-node-resolve")();

let entryPoint = "src/index.js";
let target = "bundle.js";
let plugins = [nodeResolve, babel(babelConfig)];
if(process.env.DISKLESS) { // adjust configuration to use virtual entry point
    let fs = require("fs");
    let path = require("path");

    let root = path.resolve(__dirname, "src");
    let diskless = require("./diskless")(root, nodeResolve);

    // replace input file with its source code
    let source = fs.readFileSync(path.resolve(__dirname, entryPoint), "utf8");
    let virtual = "entry_point.js";
    diskless.register(virtual, source);

    entryPoint = `diskless:${virtual}`;
    target = "bundle_virtual.js";
    plugins = [diskless].concat(plugins);
}

module.exports = {
    input: entryPoint,
    output: {
        file: target,
        format: "iife"
    },
    plugins: plugins
};

util.js

export function log(level, message) {
    console.log(`[${level}]`, message);
}