gulp: blanking output if Browserify fails - gulp

Question

I'm using Browserify in my gulpfile.js like so:
browserify("src/main.js").bundle()
.on("end", function() {
console.log("compiled JavaScript via Browserify");
})
.on("error", function(err) {
console.warn("ERROR: Browserify failed", err);
})
.pipe(source("bundle.js"))
.pipe(gulp.dest("./dist"));
However, it's easy to miss compilation errors - so I'd prefer to blank dist/bundle.js (or insert an alert("ERROR");) instead of just reporting errors in the terminal.
My attempts to implement this failed due to what I assume is a race condition (pipe conclusion overwriting file operations in the "error" event handler), so I'd be grateful for some advice on how to do this properly.

Answer 1

If you think your issue is due to the asynchronicity of the code, you can use async or q to dictate the order in which your code executes (try async.waterfall, for example).

Answer 2

If you want to blank out a file on error, you can write a gulp stream handler that handles control structures that get generated in the stream and blanks the file out, otherwise just passes it through. Here is the code of the handler:
var through2 = require('through2');
var gutil = require('gulp-util');
var blank = function () {
var blank = false;
return through2.obj(
function (file, encoding, cb) {
if (!file.control && !blank) {
this.push(file);
} else if (file.control) {
blank = true;
} else if (file.path && blank) {
var newFile = new gutil.File({
base: file.base,
cwd: file.cwd,
path: file.path,
contents: new Buffer('')
});
this.push(newFile);
}
cb();
}, function (cb) {
cb();
});
};
Then you need to catch the error and generate a control structure. This can be done like this, in the on("error" handler, you place the following line of code:
this.push({"control": "failed"});
If you make the blank handler the last handler in the stream before the output, like this:
.pipe(blank())
.pipe(gulp.dest('./dist'));
Then you will have an empty file instead of the processed one. Of course you could modify this to write the error information to the file instead or do any number of things.
That having been said, why would you simply not want the processing to stop when you encounter this error? Any unhandled stream error should stop processing.