jscrambler/dist/zip.js

Jscrambler Code Integrity API client.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.unzip = unzip;
exports.zip = zip;
exports.zipSources = zipSources;
require("core-js/modules/es.array.reverse.js");
require("core-js/modules/es.regexp.exec.js");
require("core-js/modules/web.dom-collections.iterator.js");
var _lodash = _interopRequireDefault(require("lodash.size"));
var _jszip = _interopRequireDefault(require("jszip"));
var fs = _interopRequireWildcard(require("fs/promises"));
var _path2 = require("path");
var _util = require("util");
var _utils = require("./utils");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
// TODO Replace `sync` functions with async versions

const debug = !!process.env.DEBUG;
async function zip(files, cwd, runBeforeProtection) {
  debug && console.log('Zipping files', (0, _util.inspect)(files));
  // Flag to detect if any file was added to the zip archive
  let 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;
    const zipFile = new _jszip.default();
    const zipFileData = await fs.readFile(files[0]);
    return await zipFile.loadAsync(zipFileData);
  }
  const zipFile = new _jszip.default();
  for (let 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;
    }
    let buffer, name;
    let sPath;
    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 (!(await fs.stat(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 = await fs.readFile(sPath);
      runBeforeProtection.reverse().map(element => {
        buffer = (0, _utils.concatenate)(element, cwd, sPath, buffer);
      });
    } else {
      // Else if it's a directory path
      zipFile.folder(sPath);
    }
    if (name) {
      hasFiles = true;
      zipFile.file(name, buffer);
    }
  }
  if (!hasFiles) {
    throw new Error('No source files found. If you intend to send a whole directory sufix your path with "**" (e.g. ./my-directory/**)');
  }
  return zipFile;
}
function zipSources(sources) {
  const zipFile = new _jszip.default();
  const fileNames = sources.map(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) {
  const [full, drv, path] = _path.match(/^([a-z]:)(.*)/i);
  return {
    drv,
    path
  };
}
async function unzip(zipFile, dest) {
  let stream = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  const zip = new _jszip.default();
  await zip.loadAsync(zipFile);
  const _size = (0, _lodash.default)(zip.files);
  const results = [];

  // eslint-disable-next-line no-restricted-syntax
  for (const file in zip.files) {
    if (!zip.files[file].dir) {
      const buffer = await zip.file(file).async('nodebuffer');
      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;
        const lastDestChar = dest[dest.length - 1];
        if (_size === 1 && lastDestChar !== '/' && lastDestChar !== '\\') {
          destPath = dest;
          const parentPath = (0, _path2.dirname)(destPath);
          await fs.mkdir(parentPath, {
            recursive: true
          });
        } else {
          let _file = file;
          // Deal with win path join c:\dest\:c\src
          if (isWinAbsolutePath(_file)) {
            _file = parseWinAbsolutePath(_file).path;
          }
          destPath = (0, _path2.join)(dest, _file);
          await fs.mkdir((0, _path2.dirname)(destPath), {
            recursive: true
          });
        }
        await fs.writeFile(destPath, buffer);
      }
    }
  }
  if (!stream) {
    dest(results);
  }
}