mopus v3.1.31

Mopus

Mopus is an open-source module bundler in the way of webpack, built specifically for the needs of another library : Nixy.

In comparison with Webpack, Mopus is extremely lightweight and considerably faster for small projects. Compiling your project becomes a matter of milliseconds.

Mopus has easy solutions for HMR (hot module resolution) and custom actions on module loading.

Mopus is still in beta version. If you find any bug, let me know ☺.

Installation

From the command line :

npm install -g mopus

Or, if you prefer to install it locally :

npm install mopus

Usage

You can use Mopus from the command line or with a Node project.

Like Webpack, Mopus uses a configuration file mopus.json. If the file is not present, default configuration will be used.

Using from the command line

If you've installed Mopus globally, make sure your global node modules path is added to your environment variables. To check if you can access mopus CLI, write in your console : mopus -v.

If you've installed Mopus locally, use npx : npx mopus -v.

To build your project, go to the folder with the mopus.json file and execute : mopus.

You can pass options :

mopus main.js -o output.js

will build using the main.js file as an entry point, and will write the result into the file output.js.

You can pass any option (except object and array options) by adding the prefix -- before the option name (example: --output). See the configuration section for the list of all the options available.

Using from a Node program

First, require Mopus :

const Mopus = require('mopus')

Then use it this way :

const mopus = new Mopus({
	entry: 'main.js',
	output: 'bundle.js',
})
mopus.compile()

This will compile using the main.js file as an entry point, and will write the result into the file bundle.js.

Getting the result as a String or a Buffer

If you don't want the output to be written in a file but instead get the result as a string, use the option outputType.

const Mopus = require('mopus')
const mopus = new Mopus({
	entry: 'main.js',
	output: 'myProject',
	outputType: 'string',  // 'file' | 'string' | 'buffer'. Default is 'file'.
})
let str = mopus.compile().myProject

Importing modules

You can import a module using the import statement or the usual require function (see here to learn how to use import).

Let's suppose we have two files main.js and Zabu.js in the same folder :

// main.js
import {Zabu} from './Zabu'  // the '.js' extension is unnecessary
new Zabu

// Zabu.js
export {Zabu}
class Zabu {
	constructor() {
		console.log('Zabu!')
	}
}

Now let's compile our two files using the CLI : mopus main.js -o bundle.js

And let's execute it : node bundle.js

Then we should see the message Zabu! appearing.

Exporting values

For a better understanding, I advice to put the export statements at the very top of your file - even before the imports.

See here to learn how to use the export statement.

Having multiple projects

Mopus is perfect when you need to generate several bundles which share common files but use different configurations.

For example, you may need to compile two projects, the second one being a minified version of the first one :

// mopus.json
{
	"entry": "main.js",
	"projects": [
		{
			"output": "bundle.js"
		},
		{
			"output": "bundle.min.js",
			"minify": true
		}
	]
}

Then, running mopus on the CLI will output two files : bundle.js and bundle.min.js.

If files are shared between different projects, they will only be parsed once by mopus.

Class fields

Class fields is a Javascript feature that will eventually come. For now, without a compiler like Babel or Typescript we need to declare all of our class fields in the constructor, preceded by a this.

Mopus naturally transform class fields into standard javascript. The following file :

class Point {
	static instances = 0
	x = 0
	y = 0
	constructor() {
		Point.instances++
	}
}

will be transformed (and bundled) into :

class Point {
	constructor() {
		this.x = 0
		this.y = 0
		Point.instances++
	}
}
Point.instances = 0

If you don't want Mopus to transform class fields, set the option processClassFields to false.

Configuration

Global options

Global options cannot be assigned to a project object, only as a direct mopus option (common to every project).

See also the project options.

Project options

Project options can be used specifically in a project object, or as a global option that will apply to every project (if not overwritten by another project option).

Additional notes

Speed and minification

Mopus internally uses the excellent Butternut minifier by Richard Harris. Butternut is amongst the fastest minifiers, still minifying the output slow down the whole process. In the future, Mopus will closely integrates minification to its core to make it as light as a breeze.

If you care about achieving maximum speed, don't minify your project and disable logs.

Comments

Comments are automatically removed by Mopus. Most of the times they are not needed because the resulting bundle is made to be executed, not reverse-engineered.

Nonetheless there are cases when keeping comments is useful, so I plan to add support for comments.

Sourcemaps

Mopus does not produce sourcemaps yet. I don't plan to add sourcemaps support before the Javascript class fields proposal is live, because the most complex part about generating sourcemaps is to deal with class fields transformation.