@shockpkg/core/lib/zip.js

shockpkg core

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Zip = void 0;

var _initializerDefineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerDefineProperty"));

var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));

var _initializerWarningHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerWarningHelper"));

var _util = require("util");

var _yauzl = _interopRequireDefault(require("yauzl"));

var _decorators = require("./decorators");

var _dec, _class, _descriptor, _temp;

const yauzlOpen = _yauzl.default.open.bind(_yauzl.default);

const yauzlOpenP = (0, _util.promisify)(yauzlOpen);

const yauzlFromRAR = _yauzl.default.fromRandomAccessReader.bind(_yauzl.default);

const yauzlFromRARP = (0, _util.promisify)(yauzlFromRAR);
const openOpts = {
  lazyEntries: true
};
/**
 * Streamer Random Access Read wrapper class.
 *
 * @param streamer ZipStreamer function.
 */

class StreamerRAR extends _yauzl.default.RandomAccessReader {
  /**
   * Streamer instance.
   */
  constructor(streamer) {
    super();
    this.__streamer = void 0;
    this.__streamer = streamer;
  }
  /**
   * Read stream from range.
   *
   * @param start Range start.
   * @param end Range end.
   * @returns Readable stream.
   */
  // eslint-disable-next-line @typescript-eslint/member-naming


  _readStreamForRange(start, end) {
    return this.__streamer(start, end);
  }

}
/**
 * Zip file reader class.
 */


let Zip = (_dec = (0, _decorators.property)(false), (_class = (_temp = class Zip extends Object {
  /**
   * The zipfile instance, generic type to avoid dependency.
   */
  constructor() {
    super();
    (0, _initializerDefineProperty2.default)(this, "_zipfile", _descriptor, this);
  }
  /**
   * Open with a file.
   *
   * @param file File path.
   */


  async openFile(file) {
    this._zipfile = await yauzlOpenP(file, openOpts);
  }
  /**
   * Open with a streamer.
   *
   * @param streamer Streamer function.
   * @param totalSize Total size of file.
   */


  async openStreamer(streamer, totalSize) {
    const reader = new StreamerRAR(streamer);
    this._zipfile = await yauzlFromRARP(reader, totalSize, openOpts);
  }
  /**
   * Read zip file entries.
   * To stop reading and close file, return false from itter.
   *
   * @param itter Callback function.
   */


  async read(itter) {
    const zipfile = this._zipfile;

    if (!zipfile) {
      throw new Error('Zip instance not opened');
    }

    this._zipfile = null;
    await new Promise((resolve, reject) => {
      let error = null;

      const next = err => {
        if (err) {
          error = err;
          zipfile.close();
          return;
        }

        zipfile.readEntry();
      };

      zipfile.on('error', next);
      zipfile.on('entry', async entry => {
        const path = entry.fileName.replace(/\\/g, '/');
        const dir = path.endsWith('/');
        const {
          crc32
        } = entry;
        const sizeC = entry.compressedSize;
        const sizeD = entry.uncompressedSize;

        const stream = async () => {
          const open = zipfile.openReadStream.bind(zipfile);
          const openP = (0, _util.promisify)(open);
          const r = await openP(entry);
          return r;
        };

        let done = false;

        try {
          done = await itter({
            path,
            dir,
            crc32,
            sizeC,
            sizeD,
            stream
          });
        } catch (err) {
          next(err);
          return;
        }

        if (done) {
          zipfile.close();
        } else {
          next(null);
          return;
        }
      });
      zipfile.on('close', () => {
        if (error) {
          reject(error);
          return;
        }

        resolve();
      });
      next(null);
    });
  }

}, _temp), (_descriptor = (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_zipfile", [_dec], {
  configurable: true,
  enumerable: true,
  writable: true,
  initializer: function () {
    return null;
  }
})), _class));
exports.Zip = Zip;
//# sourceMappingURL=zip.js.map