Using NPM packages in V8

Jeroen Ooms


What is V8 (not)

V8 is Google’s JavaScript engine that is used in Chrome, Node and other tools. However each of these programs implements most JavaScript functionality on top of V8. The naked V8 engine only provides basic ECMAscript, which does not include a lot of things that you might be used to. There is no I/O (network/disk), no event-loop and no DOM (window).

JS Engine Evented Network Disk DOM
Browser -
Node -
V8 - - - -

Currently the R package is just V8. Perhaps more will be added later, although both IO and DOM would require an event-loop, which disqualifies the simple eval-and-return pattern. In that case it would work more like a server (similar to the httpuv package). But for now we will be working with plain V8 and rely on R for I/O.

Can we use NPM?

Yes! But not all packages will work. Most libraries in npm are primarely written for Node or the browser. Obviously, anything that requires internet access, graphics or files is not going to work in plain V8. But there is quite a lot of stuff that does work.

Some general purpose libraries like underscore or crossfilter will work natively in V8:

ct <- v8()
ct$source(system.file("js/underscore.js", package="V8"))
ct$call("_.filter", mtcars, JS("function(x){return x.mpg < 15}"))
                     mpg cyl disp  hp drat    wt  qsec vs am gear carb
Duster 360          14.3   8  360 245 3.21 3.570 15.84  0  0    3    4
Cadillac Fleetwood  10.4   8  472 205 2.93 5.250 17.98  0  0    3    4
Lincoln Continental 10.4   8  460 215 3.00 5.424 17.82  0  0    3    4
Chrysler Imperial   14.7   8  440 230 3.23 5.345 17.42  0  0    3    4
Camaro Z28          13.3   8  350 245 3.73 3.840 15.41  0  0    3    4

However NPM assumes disk access to resolve dependencies. How is that going to work?

Browserify to the rescue

browserify logo

browserify logo

Browserify is a brilliant tool to bundle an npm package with all of its dependencies into a single js file that does not require disk access. It is mainly designed to make npm packages suitable for use on a webpage (duh) but it is useful with embedded V8 as well. To install it run:

npm install -g browserify

Example: beautify-js

Beautify-js is a simple npm package to fix linebreaks and indentation in JavaScript, HTML or CSS code. To bundle it up, run these three lines in a shell:

npm install js-beautify
echo "global.beautify = require('js-beautify');" > in.js
browserify in.js -o bundle.js

The first line will install js-beautify in a the current dir under node_modules. The second line creates the input file for browserify. In this case it consists of only one line that imports the js-beautify library and exports it to the global environment. The third line runs browserify and saves the output to a new file bundle.js.

We now have a file that we can load in V8. Assuming you ran the above commands in your Desktop directory:

ct <- v8()

Let’s see whats in our global environment now:

 [1] "console"      "print"        "global"       "ArrayBuffer" 
 [5] "Int8Array"    "Uint8Array"   "Int16Array"   "Uint16Array" 
 [9] "Int32Array"   "Uint32Array"  "Float32Array" "Float64Array"
[13] "DataView"     "beautify"    

The beautify library is available now.

Lets beautify stuff

To beautify JavaScript we need to use the js_beautify function. See the package homepage for a full list of options.

test <- "(function(x,y){x = x || 1; y = y || 1; return y * x;})(4, 9)"
pretty_test <- ct$call("beautify.js_beautify", test, list(indent_size = 2))
(function(x, y) {
  x = x || 1;
  y = y || 1;
  return y * x;
})(4, 9)

The package also includes functions to beautify css and html:

html <- "<ul><li>one</li><li>two</li><li>three</li></ul>"
cat(ct$call("beautify.html_beautify", html))