feeles-ide/lib/File/BinaryFile.js

The hackable and serializable IDE to make learning material

"use strict";

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

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

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

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

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

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

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

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

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

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

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

var _md = _interopRequireDefault(require("md5"));

var _File3 = _interopRequireDefault(require("./_File"));

var _sanitizeHTML = require("./sanitizeHTML");

var BinaryFile =
/*#__PURE__*/
function (_File2) {
  (0, _inherits2.default)(BinaryFile, _File2);

  function BinaryFile(props) {
    (0, _classCallCheck2.default)(this, BinaryFile);

    if (props.composed) {
      var bin = atob((0, _sanitizeHTML.decode)(props.composed));
      var byteArray = new Uint8Array(bin.length);

      for (var i = bin.length - 1; i >= 0; i--) {
        byteArray[i] = bin.charCodeAt(i);
      }

      var blob = new Blob([byteArray.buffer], {
        type: props.type
      });
      var hash = (0, _md.default)(byteArray);
      props = (0, _objectSpread2.default)({}, props, {
        blob: blob,
        hash: hash
      });
    }

    if (props.blob && !props.blobURL) {
      var blobURL = URL.createObjectURL(props.blob);
      props = (0, _objectSpread2.default)({}, props, {
        blobURL: blobURL
      });
    }

    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(BinaryFile).call(this, props));
  }

  (0, _createClass2.default)(BinaryFile, [{
    key: "set",
    value: function set(change) {
      if (!change.blob && this.hash) {
        change.hash = this.hash;
      }

      var seed = (0, _objectSpread2.default)({}, this.serialize(), change);
      seed.key = this.key;
      seed.lastModified = Date.now();
      return new BinaryFile(seed);
    }
  }, {
    key: "compose",
    value: function () {
      var _compose = (0, _asyncToGenerator2.default)(
      /*#__PURE__*/
      _regenerator.default.mark(function _callee() {
        var serialized, credits, dataURL, base64;
        return _regenerator.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                serialized = this.serialize();
                delete serialized.blob;

                if (this.sign && this.sign === this.credit) {
                  credits = this.credits.concat((0, _objectSpread2.default)({}, this.sign, {
                    timestamp: Date.now(),
                    hash: this.hash
                  }));
                  serialized.credits = JSON.stringify(credits);
                } else {
                  serialized.credits = JSON.stringify(this.credits);
                }

                _context.next = 5;
                return this.toDataURL();

              case 5:
                dataURL = _context.sent;
                base64 = dataURL.substr(dataURL.indexOf(',') + 1);
                serialized.composed = (0, _sanitizeHTML.encode)(base64);
                return _context.abrupt("return", serialized);

              case 9:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function compose() {
        return _compose.apply(this, arguments);
      }

      return compose;
    }()
    /**
     * @param file File|Blob
     * @return Promise gives BinaryFile
     */

  }, {
    key: "blob",
    get: function get() {
      return this.props.blob;
    }
  }, {
    key: "blobURL",
    get: function get() {
      return this.props.blobURL;
    }
  }, {
    key: "hash",
    get: function get() {
      return this.props.hash;
    }
  }], [{
    key: "load",
    value: function load(file) {
      return new Promise(function (resolve) {
        // get hash of TypedArray from binary
        var reader = new FileReader();

        reader.onload = function (e) {
          var typedArray = new Uint8Array(e.target.result);
          var hash = (0, _md.default)(typedArray);
          resolve(hash);
        };

        reader.readAsArrayBuffer(file);
      }).then(function (hash) {
        return new BinaryFile({
          type: file.type,
          name: file.name || BinaryFile.defaultProps.name,
          blob: file,
          hash: hash,
          lastModified: file.lastModified
        });
      });
    }
  }]);
  return BinaryFile;
}(_File3.default);

exports.default = BinaryFile;
(0, _defineProperty2.default)(BinaryFile, "defaultProps", {
  name: '.BinaryFile',
  blob: null,
  sign: null
});
(0, _defineProperty2.default)(BinaryFile, "defaultOptions", {
  isTrashed: false
});
(0, _defineProperty2.default)(BinaryFile, "visible", _File3.default.visible.concat('blob'));