Skip to content
A wrapper library for the HTML5 Filesystem API what reuses UNIX commands (cp, mv, ls) for its API.
Branch: master
Clone or download
Latest commit 53d0deb Sep 16, 2016
Type Name Latest commit message Commit time
Failed to load latest commit information.
demos Use closure compiler (js), add gulp, prep for npm release Sep 16, 2016
dist Rev 0.4.5 Sep 16, 2016
src Use closure compiler (js), add gulp, prep for npm release Sep 16, 2016
tests Fixes issue 32 Jun 13, 2013
LICENSE Updating version Mar 14, 2013 Rev 0.4.4 Sep 16, 2016
component.json Rev 0.4.5 Sep 16, 2016


filer.js is a well-tested wrapper library for the HTML5 Filesystem API, an API which enables web applications to read and write files and folders to its own sandboxed filesystem.

Unlike other wrapper libraries [1, 2], filer.js takes a different approach by reusing familiar UNIX commands (cp, mv, ls) for its API. The goal is to make the HTML5 API more approachable for developers that have done file I/O in other languages.

Check out the demo app:

Demo app screenshot

Supported Browsers

  • Chrome

The HTML5 Filesystem API is only supported in Chrome. Therefore, the library only works in Chrome.

Getting started

I highly recommended that you familiarize yourself with the HTML5 Filesystem API. I've written a book on the topic, "Using the HTML5 Filesystem API", and there are two great articles on HTML5 Rocks that walk you through all of its different methods and capabilities:

  1. Exploring the FileSystem APIs
  2. The Synchronous FileSystem API for Workers


Install the polyfill:

npm install filer.js --save

Drop it on your page:

<script src="node_modules/filer/dist/filer.min.js" async></script>

The underlying Filesystem API is asynchronous, therefore, the library calls are mostly asynchronous. This means you'll be passing callbacks all over the place.

First, create a Filer object:

var filer = new Filer();

Next, initialize the library:

filer.init({persistent: false, size: 1024 * 1024}, function(fs) {
  // filer.size == Filer.DEFAULT_FS_SIZE
  // filer.isOpen == true
  // filer.fs == fs
}, onError);

The first argument is an optional initialization object that can contain two properties, persistent (the type of storage to use) and size. The second and third arguments are a success and error callback, respectively:

The success callback is passed a LocalFileSystem object. If you don't initialize the the filesystem with a size, a default size of Filer.DEFAULT_FS_SIZE (1MB) will be used. Thus, the previous call can be simplified to:

filer.init({}, function(fs) {
}, onError);

filer.init(); // All parameters are optional.

Error handling

Many methods take an optional error callback as their last argument. It can be a good idea to setup a global error handler for all methods to use:

function onError(e) {
  console.log('Error' +;


General rule of thumb

For versatility, the library accepts paths to files or directories as string arguments (a path) or as filesystem URLs. It also can take the FileEntry/DirectoryEntry object representing the file/directory.


List the contents of a directory.

The first arg is a path, filesystem URL, or DirectoryEntry to return the contents for. The second and third arguments, are success and error callbacks, respectively.

// Pass a path.'/', function(entries) {
  // entries in the root directory.
}, onError);'.', function(entries) {
  // entries in the current working directory.
}, onError);'path/to/some/dir/', function(entries) {
  // entries in "path/to/some/dir/"
}, onError);

// Pass a filesystem: URL.
var fsURL = filer.fs.root.toURL(); // e.g. 'filesystem:';, function(entries) {
  // entries in the root folder.
}, onError);

// Pass a DirectorEntry., function(entries) {
  // entries in the root directory.
}, onError);


Displays disk space usage.

The first and second arguments, are success and error callbacks. Used space, Free space and currently allocated total space are passed to the success callback.

filer.df(function(used, free, cap) {
  // used, free and capacity in bytes.
}, onError);


Allows you to change into another directory.

This is a convenience method. When using cd(), future operations are treated relative to the new directory. The success callback is passed the DirectoryEntry changed into.

// Passing a path.'/path/to/folder', function(dirEntry) {
}, onError);

// Passing a filesystem: URL.
var fsURL = filer.fs.root.toURL(); // e.g. 'filesystem:'; + 'myDir', function(dirEntry) {
  // cwd becomes /myDir.
}, onError);

// Passing a DirectoryEntry., function(dirEntry2) {
  // dirEntry == dirEntry2
}, onError);'/path/to/folder'); // Both callbacks are optional.


Creates an empty file.

create() creates an empty file in the current working directory. If you wish to write data to a file, see the write() method.

Important Note : Directory path leading to the file must exist before calling create!

filer.create('myFile.txt', false, function(fileEntry) {
  // == 'myFile.txt'
}, onError);

filer.create('/path/to/some/dir/myFile.txt', true, function(fileEntry) {
  // fileEntry.fullPath == '/path/to/some/dir/myFile.txt'
}, onError);

filer.create('myFile.txt'); // Last 3 args are optional.

The second (optional) argument is a boolean. Setting it to true throws an error if the file you're trying to create already exists.


Creates an empty directory.

filer.mkdir('myFolder', false, function(dirEntry) {
  // dirEntry.isDirectory == true
  // == 'myFolder'
}, onError);

You can pass mkdir() a folder name or a path to create. In the latter, it behaves like UNIX's mkdir -p, creating each intermediate directory as needed.

For example, the following would create a new hierarchy ("music/genres/jazz") in the current folder:

filer.mkdir('music/genres/jazz/', false, function(dirEntry) {
  // == 'jazz' // Note: dirEntry is the last entry created.
}, onError);

The second argument to mkdir() a boolean indicating whether or not an error should be thrown if the directory already exists. The last two are a success callback and optional error callback.


Removes a file or directory.

If you're removing a directory, it is removed recursively.

filer.rm('myFile.txt', function() {
}, onError);

filer.rm('/path/to/some/someFile.txt', function() {
}, onError);

var fsURL = filer.pathToFilesystemURL('/path/to/some/directory');
filer.rm(fsURL, function() {
}, onError);

filer.rm(directorEntry, function() {
}, onError);


Copies a file or directory.

The first argument to cp() is the source file/directory you wish to copy, followed by the destination folder for the source to be copied into.

Note: The src and dest arguments need to be the same type. For example, if pass a string path for the first argument, the destination cannot be a FileEntry. It must be a string path (or filesystem URL) as well.

// Pass string paths.
filer.cp('myFile.txt', '/path/to/other/folder', null, function(entry) {
  // entry.fullPath == '/path/to/other/folder/myFile.txt'
}, onError);

// Pass filesystem URLs.
var srcFsURL = 'filesystem:';
var destFsURL = 'filesystem:';
filer.cp(srcFsURL, destFsURL, null, function(entry) {
  // filer.pathToFilesystemURL(entry.fullPath) == 'filesystem:'
}, onError);

// Pass Entry objects.
filer.cp(srcEntry, destinationFolderEntry, null, function(entry) {
}, onError);

// Mixing string paths with filesystem URLs work too:
filer.cp(srcEntry.toURL(), '/myDir', null, function(entry) {
}, onError);

If you wish to copy the entry under a new name, specify the third newName argument:

// Copy myFile.txt to myFile2.txt in the current directory.
filer.cp('myFile.txt', '.', 'myFile2.txt', function(entry) {
  // == 'myFile2.txt'
}, onError);


Moves a file or directory.

The first argument to move is the source file or directory to move, the second is a destination directory, and the third is an optional new name for the file/folder when it is moved.

// Pass string paths.'path/to/myfile.mp3', '/another/dir', null, function(fileEntry) {
  // fileEntry.fullPath == '/another/dir/myfile.mp3'
}, onError);

// Pass a filesystem URL. This example renames file.txt to somethingElse.txt in
// the same directory.'filesystem:', '.', 'somethingElse.txt', function(fileEntry) {
  // fileEntry.fullPath == '/somethingElse.txt'
}, onError);

// Pass a FileEntry or DirectoryEntry., destDirEntry, function(dirEntry) {
  // folder is moved into destDirEntry
}, onError);'myFile.txt', './someDir'); // The new name and both callbacks are optional.


Returns a File object.

// Pass a path.'myFile.txt', function(file) {
  // Use FileReader to read file.
  var reader = new FileReader();
  reader.onload = function(e) {
}, onError);

// Pass a filesystem URL., function(file) {
}, onError);

// Pass a FileEntry., function(file) {
}, onError);


Writes content to a file.

write() takes a string (path or filesystem URL) or FileEntry as it's first argument. This is the file to write data to. If the does not exist, it is created. Otherwise, the file's contents are overwritten if it already exists.

The second argument is an object with three properties:

  • data: the content to write into the file.
  • type: optional mimetype of the content.
  • append: optional true if data should be appended to the file.

The success callback for this method is passed the FileEntry for the file that was written to and the FileWriter object used to do the writing.

// Write files from a file input.
document.querySelector('input[type="file"]').onchange = function(e) {
  var file =[0];
  filer.write(, {data: file, type: file.type}, function(fileEntry, fileWriter) {
  }, onError);

// Create a Blob and write it out.
var bb = new BlobBuilder();
bb.append('body { background: red; }');
filer.write('styles.css', {data: bb.getBlob('text/css'), type: 'text/css'},
  function(fileEntry, fileWriter) {

// Create a typed array and write the ArrayBuffer.
var uint8 = new Uint8Array([1,2,3,4,5]);
filer.write(fileEntry, {data: uint8.buffer},
  function(fileEntry, fileWriter) {

// Write string data.
filer.write('path/to/file.txt', {data: '1234567890', type: 'text/plain'},
  function(fileEntry, fileWriter) {

// Append to a file.
filer.write('path/to/file.txt', {data: '1234567890', type: 'text/plain', append: true},
  function(fileEntry, fileWriter) {

Utility methods

The library contains a few utility methods to help you out.


Util.fileToArrayBuffer(blob, function(arrayBuffer) {

var blob = Util.arrayBufferToBlob((new Uint8Array(10)).buffer, opt_contentType);

Util.arrayBufferToBinaryString((new Uint8Array(10)).buffer, function(binStr) {

Util.strToObjectURL(binaryStr, opt_contentType);

Util.strToDataURL(binaryStr, contentType) // e.g. "data:application/pdf;base64,Ym9keSB7IG..."
// For plaintext (non-binary data):
// Util.strToDataURL('body { background: green; }', 'text/css', false) == data:text/css,body { background: green; }

Util.arrayToBinaryString(bytes); // bytes is an Array, each varying from 0-255.

Util.getFileExtension('myfile.txt') == '.txt'

// Util.toArray(DOMList/NodeList) == Array
document.querySelector('input[type="file"]').onchange = function(e) {
  Util.toArray(this.files).forEach(function(file, i) {
    // blah blah blah.



Install the dependencies and compile the library by running gulp:

npm install

This will output a built file to dist/filer.min.js.


To cut a new release, run:

npm version patch

Also update components.json with the new version. Then run:

npm publish


You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.