jscrambler/dist/zip.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.outputFileSync = undefined;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); // TODO Replace `sync` functions with async versions

exports.zip = zip;
exports.zipSources = zipSources;
exports.unzip = unzip;

var _lodash = require('lodash.size');

var _lodash2 = _interopRequireDefault(_lodash);

var _temp = require('temp');

var _temp2 = _interopRequireDefault(_temp);

var _jszip = require('jszip');

var _jszip2 = _interopRequireDefault(_jszip);

var _fsExtra = require('fs-extra');

var _path2 = require('path');

var _q = require('q');

var _util = require('util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var debug = !!process.env.DEBUG;

// ./zip.js module is excluded from browser-like environments. We take advantage of that here.
exports.outputFileSync = _fsExtra.outputFileSync;
function zip(files, cwd) {
  debug && console.log('Zipping files', (0, _util.inspect)(files));
  var deferred = (0, _q.defer)();
  // Flag to detect if any file was added to the zip archive
  var hasFiles = false;
  // Sanitize `cwd`
  if (cwd) {
    cwd = (0, _path2.normalize)(cwd);
  }
  // If it's already a zip file
  if (files.length === 1 && /^.*\.zip$/.test(files[0])) {
    hasFiles = true;
    var _zip = new _jszip2.default();
    var zipFile = (0, _fsExtra.readFileSync)(files[0]);

    (0, _fsExtra.outputFileSync)(_temp2.default.openSync({ suffix: '.zip' }).path, zipFile);
    zipFile = _zip.load(zipFile);
    deferred.resolve(zipFile);
  } else {
    var _zip2 = new _jszip2.default();
    for (var i = 0, l = files.length; i < l; ++i) {
      // Sanitise path
      if (typeof files[i] === 'string') {
        files[i] = (0, _path2.normalize)(files[i]);
        if (files[i].indexOf('../') === 0) {
          files[i] = (0, _path2.resolve)(files[i]);
        }
      }
      // Bypass unwanted patterns from `files`
      if (/.*\.(git|hg)(\/.*|$)/.test(files[i].path || files[i])) {
        continue;
      }
      var buffer = void 0,
          name = void 0;
      var sPath = void 0;
      if (cwd && files[i].indexOf && files[i].indexOf(cwd) !== 0) {
        sPath = (0, _path2.join)(cwd, files[i]);
      } else {
        sPath = files[i];
      }
      // If buffer
      if (files[i].contents) {
        name = (0, _path2.relative)(files[i].cwd, files[i].path);
        buffer = files[i].contents;
      } else if (!(0, _fsExtra.statSync)(sPath).isDirectory()) {
        // Else if it's a path and not a directory
        if (cwd && files[i].indexOf && files[i].indexOf(cwd) === 0) {
          name = files[i].substring(cwd.length);
        } else {
          name = files[i];
        }
        buffer = (0, _fsExtra.readFileSync)(sPath);
      } else {
        // Else if it's a directory path
        _zip2.folder(sPath);
      }
      if (name) {
        hasFiles = true;
        _zip2.file(name, buffer);
      }
    }
    if (hasFiles) {
      var tempFile = _temp2.default.openSync({ suffix: '.zip' });
      (0, _fsExtra.outputFileSync)(tempFile.path, _zip2.generate({ type: 'nodebuffer' }), {
        encoding: 'base64'
      });
      files[0] = tempFile.path;
      files.length = 1;
      deferred.resolve(_zip2);
    } else {
      throw new Error('No source files found. If you intend to send a whole directory sufix your path with "**" (e.g. ./my-directory/**)');
    }
  }

  return deferred.promise;
}

function zipSources(sources) {
  var zipFile = new _jszip2.default();
  var fileNames = sources.map(function (source) {
    zipFile.file(source.filename, source.content);
    return source.filename;
  });

  if (debug) {
    console.log('Zipping files', (0, _util.inspect)(fileNames));
  }
  return Promise.resolve(zipFile);
}

function isWinAbsolutePath(path) {
  return (0, _path2.isAbsolute)(path) && /^([a-z]:)(.*)/i.test(path);
}

function parseWinAbsolutePath(_path) {
  var _path$match = _path.match(/^([a-z]:)(.*)/i),
      _path$match2 = _slicedToArray(_path$match, 3),
      full = _path$match2[0],
      drv = _path$match2[1],
      path = _path$match2[2];

  return {
    drv: drv,
    path: path
  };
}

function unzip(zipFile, dest) {
  var stream = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

  var zip = new _jszip2.default(zipFile);
  var _size = (0, _lodash2.default)(zip.files);

  var results = [];

  for (var file in zip.files) {
    if (!zip.files[file].options.dir) {
      var buffer = zip.file(file).asNodeBuffer();

      if (typeof dest === 'function') {
        if (stream) {
          dest(buffer, file);
        } else {
          results.push({ filename: file, content: buffer.toString() });
        }
      } else if (dest && typeof dest === 'string') {
        var destPath;

        var lastDestChar = dest[dest.length - 1];
        if (_size === 1 && lastDestChar !== '/' && lastDestChar !== '\\') {
          destPath = dest;
        } else {
          var _file = file;
          // Deal with win path join c:\dest\:c\src
          if (isWinAbsolutePath(_file)) {
            _file = parseWinAbsolutePath(_file).path;
          }
          destPath = (0, _path2.join)(dest, _file);
        }
        (0, _fsExtra.outputFileSync)(destPath, buffer);
      }
    }
  }

  if (!stream) {
    dest(results);
  }
}