Snowpack is a post-install tool. It runs after npm install, and it essentially exists to convert your npm packages (in your node_modules/
directory) into JS files that run in the browser without a bundler (written to a web_modules/
directory).
Creating a sample app
In this tutorial, we are going to create a simple demo app that is going to make use of a library called finance
. We are going to create an app to calculate simple interest from principal, rate and time. This application has got no fancy user interface or something. It just calls the method from the library by giving parameters and print the result in the console.
First, let's set up the application by creating the necessary files.
$ mkdir snowpack-demo
$ cd snowpack-demo
$ npm init -y
$ touch index.html
$ mkdir src
$ touch src/app.js
index.html
This is how our index.html file will look like. As you can see, there's nothing much on the page apart from the script
tag at the bottom. This script tag includes a file called app.js
from the src
folder of the app and having the attribute type set as module
. This means that app.js
is an ES module that can be used directly on the page. We will see what goes inside the app.js
file later.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Snowpack Demo</title>
</head>
<body>
<h1>Hello World</h1>
<script type="module" src="/src/app.js"></script>
</body>
</html>
snowpack-demo/package.json
This is how our package.json
will look like for the demo app. The important thing to note here is the dependency of finance
package.
{
"name": "snowpack-demo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"finance": "1.0.0"
}
}
Creating a dummy package inside node_modules
And now for this example, we are not going to actually install any npm package. We are going to create custom packages on the fly within the node_modules
folder. That's how node_modules
work, at the end of the day all the packages are just a folder of files with a package manifest, in other words, a package.json
. Hence in order to create a new package, all you need is two things: one package.json and the source file.
For the finance package we were talking about earlier, we are going to create the package in the same way as below.
$ mkdir node_modules
$ cd node_modules
$ mkdir finance
$ cd finance
$ npm init -y
$ touch index.js
package: finance
And the package finance will contain two functions: one for calculating simple interest from principal, rate and time and the other one including the principal. We will be using only the simpleInterest function for our demo. The other one just exists for the sake of it.
import { add, multiply, divide } from 'math';
export function simpleInterestPrincipal(principal, rate, time) {
return multiply(
principal,
add(1, multiply(divide(rate,100),
time)));
}
export function simpleInterest(principal, rate, time) {
return multiply(principal, divide(rate,100), time);
}
finance/package.json
The package.json
for the finance
module is a normal package.json manifest with one exception. We are adding the module
field to point out the ESM version of this module by telling where it resides. Since we have already written the package using ES import and export statements, the value of this field is the same as the main field which points to index.js
{
"name": "finance",
"version": "1.0.0",
"description": "",
"main": "index.js",
"module": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"math": "1.0.0"
}
}
package: math
Now it's time to take a look at the math
package. It's a simple library exposing primitive operations like add, multiple, divide, etc., and it follows Common JS export system. The reason it is using CMD is to demonstrate the capabilities of Snowpack in handling Common JS modules. Snowpack can also bundle Common JS modules but which are actually the internal dependencies of your parent packages.
{
"name": "math",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
math / index.js
Below are the contents of the math
library.
module.exports = {
add: function(a,b) {
return a + b;
},
subtract: function(a,b) {
return a - b;
},
multiply: function(a, b) {
return a * b;
},
divide: function(a,b) {
return a / b;
},
square: function(a) {
return a * a;
}
};
Now the dependency tree of our demo app looks like this.
Now just run Snowpack, since we already have files inside node_modules
we don't have to do npm install
.
$ snowpack
✔ snowpack installed: finance. [0.06s]
$
Snowpack will read the dependencies from the package.json
and start bundling them. Each individual dependency is built with all its dependent packages that are flattened into a single file. As you can see below, the finance
and math
packages are bundled into a single file in the new web_modules
directory called finance.js
. And this is the file, which we will be consuming in our demo app.
Now if you inspect the finance.js
file in your web_modules
folder.
Now we can use the finance.js
from the web_modules
folder in our app.js
src/app.js
import { simpleInterest } from '../web_modules/finance.js';
console.log('Hello Snowpack');
console.log(simpleInterest(10000, 3.85, 5));
Peer Dependencies
Now, what about peer dependencies? Snowpack is very well equipped for handling peer dependencies in your applications also. It will properly bundle your dependencies by putting the commonly used code such as peer dependencies inside a common folder so that the packages which are consuming these can easily access the same without redundancy.
The dependency tree of our app is very simple we have only two packages finance
which is depending on math
. Let's introduce a new package called bmi
which will expose methods for calculating bmi
(body mass index). The bmi
package is also depending on math
package for its calculation. Hence our math
package now becomes a peer dependency for finance
and bmi
.
We are going to follow the same steps for creating the bmi
package just as we did for finance
.
$ cd node_modules
$ mkdir bmi
$ cd bmi
$ npm init -y
$ touch index.js
package/bmi
import { divide, square } from 'math';
export default function(weight, height) {
return divide(weight / square(height));
}
Now add the same package to the dependencies
list for the demo app in package.json
.
{
"name": "snowpack-demo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"finance": "1.0.0",
"bmi": "1.0.0"
}
}
The dependency tree of our demo will now look like this:
Now run snowpack again to bundle the newly added dependencies.
$ snowpack
✔ snowpack installed: finance, bmi. [0.09s]
$
You can optionally add “snowpack” as a "prepare" script to your package.json
and npm/yarn will automatically run it after every new dependency install. This is recommended so that the new dependencies are automatically included in your web_modules/
directory immediately.
/* package.json */
"scripts": {
"prepare": "snowpack"
}
After installing and running Snowpack the bundled files inside web_modules
directory will be three Javascript files. One for the bmi
package, one for the finance
package and we now have a common
directory which contains the common code in the file named index-093dfa0c.js
used by both the packages, which is actually the math
package code.
If you inspect the contents of the file in the web_modules
folder you can see yourself that Snowpack changed both the bmi
and finance
package to import from the common math
package bundled.
This is how the bundled bmi
package will look like now.
And this is how the bundled finance
package will look like.
And if you are curious about what goes inside the common index
file, as I mentioned previously it just contains the code of the math package.
Now we can import the bmi
package into our demo application from the web_modules
folder like below:
src/app.js
import { simpleInterest } from '../web_modules/finance.js';
import { bmi } from '../web_modules/bmi.js';
console.log('Simple Interest');
console.log(simpleInterest(10000, 3.85, 5));
console.log('Body Mass Index (BMI)');
console.log(bmi(75, 1.8));
Production Builds
Snowpack is not only optimized for a development environment but also for production builds. You can create a compressed or minified version of your dependencies for using in production environments and deploying with Snowpack. It also generates source maps when you are bundling for production. All you need to do is to pass the --optimize
flag while running Snowpack.
$ snowpack --optimize
Tree Shaking
Snowpack helps you to remove any unused code from your dependencies (when “Automatic Mode” is enabled via the --include
flag). In order for Tree shaking to work properly, we need to have ESM compatible versions for all your packages. Since our math package is based on Common JS module system, we need to have a separate ESM version for the same as below.
It is actually quite easy all you have to do is to convert them using export syntax for each method which is exported from the math package instead of using the module.exports
.
math/index-esm.js
export function add(a, b) {
return a + b;
};
export function subtract(a, b) {
return a - b;
};
export function multiply(a, b) {
return a * b;
};
export function divide(a, b) {
return a / b;
};
export function square(a) {
return a * a;
};
And you also need to make some changes with the package.json
of the math
package by exposing the ESM version using the module
field.
{
"name": "math",
"version": "1.0.0",
"description": "",
"main": "index.js",
"module": "index-esm.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
Now if you run Snowpack again with the --include
flag with the app.js file.
$ snowpack --include "src/app.js"
You will have your math
package properly tree-shaked or the unused subtract
methods from the package will be removed, since it is not used by any of the dependencies.
That's all from this tutorial. I hope you have a better idea now, about how Snowpack bundles your dependencies in your applications from the above examples. Please let me know for any issues or feedback about the article in the comments.
This post is originally published here
Top comments (6)
I just followed the installation instructions in your post to the letter (i.e. creating all the folders and files) up to the point in 'math / index.js' where you say:
"Now just run Snowpack, since we already have files inside node_modules we don't have to do npm install.
But just how do I run snowpack?
I'm using VSCode. There, in the terminal, I just get an error message:
There is no snowpack executable or script.
Am I missing some prerequisites (i.e. proper installation of Snowpack)?
we have to do npm install snowpack first, sorry I missed that instruction
thanks for the write up!
How do you manage support for legacy browsers such as IE11?
It is possible I guess, please refer here
snowpack.dev/#legacy-browser-support
How do I uglify the js files in production?
you have to run snowpack with --optimize flag, but a lot has changed in 2.0, please refer to official docs for more info.
snowpack.dev/#snowpack-build