82f2b76e25
We now use webpack instead of SystemJS, effectively bundling modules into one file (plus commons chunks) for every entry point. This results in a much smaller extension size (almost half). Furthermore we use yarn/npm even for extension run-time dependencies. This relieves us from manually vendoring and building dependencies. It's also easier to understand for new developers familiar with node.
161 lines
4.5 KiB
JavaScript
161 lines
4.5 KiB
JavaScript
/**
|
|
* ZipStream
|
|
*
|
|
* @ignore
|
|
* @license [MIT]{@link https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE}
|
|
* @copyright (c) 2014 Chris Talkington, contributors.
|
|
*/
|
|
var inherits = require('util').inherits;
|
|
|
|
var ZipArchiveOutputStream = require('compress-commons').ZipArchiveOutputStream;
|
|
var ZipArchiveEntry = require('compress-commons').ZipArchiveEntry;
|
|
|
|
var util = require('archiver-utils');
|
|
|
|
/**
|
|
* @constructor
|
|
* @extends external:ZipArchiveOutputStream
|
|
* @param {Object} [options]
|
|
* @param {String} [options.comment] Sets the zip archive comment.
|
|
* @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
|
|
* @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
|
|
* @param {Boolean} [options.store=false] Sets the compression method to STORE.
|
|
* @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
|
|
* to control compression.
|
|
*/
|
|
var ZipStream = module.exports = function(options) {
|
|
if (!(this instanceof ZipStream)) {
|
|
return new ZipStream(options);
|
|
}
|
|
|
|
options = this.options = options || {};
|
|
options.zlib = options.zlib || {};
|
|
|
|
ZipArchiveOutputStream.call(this, options);
|
|
|
|
if (typeof options.level === 'number' && options.level >= 0) {
|
|
options.zlib.level = options.level;
|
|
delete options.level;
|
|
}
|
|
|
|
if (typeof options.zlib.level === 'number' && options.zlib.level === 0) {
|
|
options.store = true;
|
|
}
|
|
|
|
if (options.comment && options.comment.length > 0) {
|
|
this.setComment(options.comment);
|
|
}
|
|
};
|
|
|
|
inherits(ZipStream, ZipArchiveOutputStream);
|
|
|
|
/**
|
|
* Normalizes entry data with fallbacks for key properties.
|
|
*
|
|
* @private
|
|
* @param {Object} data
|
|
* @return {Object}
|
|
*/
|
|
ZipStream.prototype._normalizeFileData = function(data) {
|
|
data = util.defaults(data, {
|
|
type: 'file',
|
|
name: null,
|
|
date: null,
|
|
mode: null,
|
|
store: this.options.store,
|
|
comment: ''
|
|
});
|
|
|
|
var isDir = data.type === 'directory';
|
|
|
|
if (data.name) {
|
|
data.name = util.sanitizePath(data.name);
|
|
|
|
if (data.name.slice(-1) === '/') {
|
|
isDir = true;
|
|
data.type = 'directory';
|
|
} else if (isDir) {
|
|
data.name += '/';
|
|
}
|
|
}
|
|
|
|
if (isDir) {
|
|
data.store = true;
|
|
}
|
|
|
|
data.date = util.dateify(data.date);
|
|
|
|
return data;
|
|
};
|
|
|
|
/**
|
|
* Appends an entry given an input source (text string, buffer, or stream).
|
|
*
|
|
* @param {(Buffer|Stream|String)} source The input source.
|
|
* @param {Object} data
|
|
* @param {String} data.name Sets the entry name including internal path.
|
|
* @param {String} [data.comment] Sets the entry comment.
|
|
* @param {(String|Date)} [data.date=NOW()] Sets the entry date.
|
|
* @param {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
|
|
* @param {Boolean} [data.store=options.store] Sets the compression method to STORE.
|
|
* @param {String} [data.type=file] Sets the entry type. Defaults to `directory`
|
|
* if name ends with trailing slash.
|
|
* @param {Function} callback
|
|
* @return this
|
|
*/
|
|
ZipStream.prototype.entry = function(source, data, callback) {
|
|
if (typeof callback !== 'function') {
|
|
callback = this._emitErrorCallback.bind(this);
|
|
}
|
|
|
|
data = this._normalizeFileData(data);
|
|
|
|
if (data.type !== 'file' && data.type !== 'directory') {
|
|
callback(new Error(data.type + ' entries not currently supported'));
|
|
return;
|
|
}
|
|
|
|
if (typeof data.name !== 'string' || data.name.length === 0) {
|
|
callback(new Error('entry name must be a non-empty string value'));
|
|
return;
|
|
}
|
|
|
|
var entry = new ZipArchiveEntry(data.name);
|
|
entry.setTime(data.date);
|
|
|
|
if (data.store) {
|
|
entry.setMethod(0);
|
|
}
|
|
|
|
if (data.comment.length > 0) {
|
|
entry.setComment(data.comment);
|
|
}
|
|
|
|
if (typeof data.mode === 'number') {
|
|
entry.setUnixMode(data.mode);
|
|
}
|
|
|
|
return ZipArchiveOutputStream.prototype.entry.call(this, entry, source, callback);
|
|
};
|
|
|
|
/**
|
|
* Finalizes the instance and prevents further appending to the archive
|
|
* structure (queue will continue til drained).
|
|
*
|
|
* @return void
|
|
*/
|
|
ZipStream.prototype.finalize = function() {
|
|
this.finish();
|
|
};
|
|
|
|
/**
|
|
* Returns the current number of bytes written to this stream.
|
|
* @function ZipStream#getBytesWritten
|
|
* @returns {Number}
|
|
*/
|
|
|
|
/**
|
|
* Compress Commons ZipArchiveOutputStream
|
|
* @external ZipArchiveOutputStream
|
|
* @see {@link https://github.com/archiverjs/node-compress-commons}
|
|
*/ |