@shockpkg/swf-projector/lib/projector.js

"use strict";

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

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

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

var _archiveFiles = require("@shockpkg/archive-files");

var _fsExtra = _interopRequireDefault(require("fs-extra"));

/**
 * Projector constructor.
 *
 * @param path Output path.
 */
class Projector extends Object {
  /**
   * Path to hdiutil binary.
   */

  /**
   * Output path.
   */
  constructor(path) {
    super();
    (0, _defineProperty2.default)(this, "hdiutil", null);
    (0, _defineProperty2.default)(this, "path", void 0);
    this.path = path;
  }
  /**
   * The movie appended marker.
   *
   * @returns Hex string.
   */


  get movieAppendMarker() {
    return '563412FA';
  }
  /**
   * Get the player file or directory as an Archive instance.
   *
   * @param path File path.
   * @returns Archive instance.
   */


  async openAsArchive(path) {
    const stat = await _fsExtra.default.stat(path);

    if (stat.isDirectory()) {
      return new _archiveFiles.ArchiveDir(path);
    }

    if (!stat.isFile()) {
      throw new Error(`Archive path not file or directory: ${path}`);
    }

    const r = (0, _archiveFiles.createArchiveByFileExtension)(path);

    if (!r) {
      throw new Error(`Archive file type unknown: ${path}`);
    }

    if (r instanceof _archiveFiles.ArchiveHdi) {
      const {
        hdiutil
      } = this;

      if (hdiutil) {
        r.mounterMac.hdiutil = hdiutil;
      }

      r.nobrowse = true;
    }

    return r;
  }
  /**
   * Write out projector with player and file.
   *
   * @param player Player path.
   * @param movieFile Movie file.
   */


  async withFile(player, movieFile) {
    const movieData = movieFile ? await _fsExtra.default.readFile(movieFile) : null;
    await this.withData(player, movieData);
  }
  /**
   * Write out projector with player and data.
   *
   * @param player Player path.
   * @param movieData Movie data.
   */


  async withData(player, movieData) {
    await this._checkOutput();
    await this._writePlayer(player);
    await this._modifyPlayer();
    await this._writeMovie(movieData);
  }
  /**
   * Check that output path is valid, else throws.
   */


  async _checkOutput() {
    if (await _fsExtra.default.pathExists(this.path)) {
      throw new Error(`Output path already exists: ${this.path}`);
    }
  }
  /**
   * Append movie data to a file.
   * Format string characters:
   * - d: Movie data.
   * - m: Marker bytes.
   * - s: Size, 32LE.
   * - S: Size, 32BE.
   * - l: Size, 64LE.
   * - L: Size, 64BE.
   *
   * @param file File to append to.
   * @param data Movie data.
   * @param format Format string.
   */


  async _appendMovieData(file, data, format) {
    const buffers = [];

    for (const c of format) {
      switch (c) {
        case 'd':
          {
            buffers.push(data);
            break;
          }

        case 'm':
          {
            buffers.push(Buffer.from(this.movieAppendMarker, 'hex'));
            break;
          }

        case 's':
          {
            const b = Buffer.alloc(4);
            b.writeUInt32LE(data.length, 0);
            buffers.push(b);
            break;
          }

        case 'S':
          {
            const b = Buffer.alloc(4);
            b.writeUInt32BE(data.length, 0);
            buffers.push(b);
            break;
          }

        case 'l':
          {
            // 64-bit, just write 32-bit, SWF cannot be larger.
            const b = Buffer.alloc(8, 0);
            b.writeUInt32LE(data.length, 0);
            buffers.push(b);
            break;
          }

        case 'L':
          {
            // 64-bit, just write 32-bit, SWF cannot be larger.
            const b = Buffer.alloc(8, 0);
            b.writeUInt32BE(data.length, 4);
            buffers.push(b);
            break;
          }

        default:
          {
            throw new Error(`Unknown format string character: ${c}`);
          }
      }
    }

    const stat = await _fsExtra.default.stat(file);

    if (!stat.isFile()) {
      throw new Error(`Path not a file: ${file}`);
    }

    const fd = await _fsExtra.default.open(file, 'a');

    try {
      for (const b of buffers) {
        // eslint-disable-next-line no-await-in-loop
        await _fsExtra.default.appendFile(fd, b);
      }
    } finally {
      await _fsExtra.default.close(fd);
    }
  }
  /**
   * Projector file extension.
   *
   * @returns File extension.
   */


}

exports.Projector = Projector;
//# sourceMappingURL=projector.js.map