feeles-ide/lib/File/_File.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 _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

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

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

var _ = require("./");

var _babelFile = _interopRequireDefault(require("./babelFile"));

var _File =
/*#__PURE__*/
function () {
  function _File(props) {
    (0, _classCallCheck2.default)(this, _File);
    this.key = props.key || getUniqueId();

    var lock = function lock() {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      return Object.freeze(Object.assign.apply(Object, [{}].concat(args)));
    };

    this.props = lock(this.constructor.defaultProps, props);
    this.options = lock(this.constructor.defaultOptions, this.props.options);
    this._separate = (0, _.separate)(this.props.name);
  }

  (0, _createClass2.default)(_File, [{
    key: "toDataURL",
    value: function () {
      var _toDataURL = (0, _asyncToGenerator2.default)(
      /*#__PURE__*/
      _regenerator.default.mark(function _callee() {
        var _this = this;

        var _dataURLCache;

        return _regenerator.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _dataURLCache = this.constructor._dataURLCache;

                if (!_dataURLCache.has(this)) {
                  _context.next = 3;
                  break;
                }

                return _context.abrupt("return", _dataURLCache.get(this));

              case 3:
                _context.next = 5;
                return new Promise(function (resolve) {
                  var reader = new FileReader();

                  reader.onload = function () {
                    var result = reader.result;

                    _dataURLCache.set(_this, result);

                    resolve(result);
                  };

                  reader.readAsDataURL(_this.blob);
                });

              case 5:
                return _context.abrupt("return", _context.sent);

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

      function toDataURL() {
        return _toDataURL.apply(this, arguments);
      }

      return toDataURL;
    }()
  }, {
    key: "collect",
    value: function () {
      var _collect = (0, _asyncToGenerator2.default)(
      /*#__PURE__*/
      _regenerator.default.mark(function _callee2() {
        var dataURL;
        return _regenerator.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.toDataURL();

              case 2:
                dataURL = _context2.sent;
                return _context2.abrupt("return", {
                  name: this.name,
                  type: this.type,
                  lastModified: this.lastModified,
                  composed: dataURL.substr(dataURL.indexOf(',') + 1),
                  options: this.options,
                  credits: this.credits
                });

              case 4:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function collect() {
        return _collect.apply(this, arguments);
      }

      return collect;
    }()
  }, {
    key: "is",
    value: function is(name) {
      return (0, _.validateType)(name, this.type);
    }
  }, {
    key: "babel",
    value: function () {
      var _babel = (0, _asyncToGenerator2.default)(
      /*#__PURE__*/
      _regenerator.default.mark(function _callee3() {
        var _babelCache, promise;

        return _regenerator.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _babelCache = this.constructor._babelCache;

                if (!_babelCache.has(this)) {
                  _context3.next = 3;
                  break;
                }

                return _context3.abrupt("return", _babelCache.get(this));

              case 3:
                promise = (0, _babelFile.default)(this);

                _babelCache.set(this, promise);

                return _context3.abrupt("return", promise);

              case 6:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function babel() {
        return _babel.apply(this, arguments);
      }

      return babel;
    }()
  }, {
    key: "rename",
    value: function rename(newName) {
      var path = this.path,
          ext = this.ext;
      var name = path + newName + ext;
      return this.set({
        name: name
      });
    }
  }, {
    key: "move",
    value: function move(newPath) {
      if (newPath.lastIndexOf('/') !== newPath.length - 1) {
        newPath += '/';
      }

      var plain = this.plain,
          ext = this.ext;
      var name = newPath + plain + ext;
      return this.set({
        name: name
      });
    }
  }, {
    key: "serialize",
    value: function serialize() {
      var _this2 = this;

      var obj = Object.create(null);
      this.constructor.visible.forEach(function (key) {
        obj[key] = _this2[key];
      });
      return obj;
    }
  }, {
    key: "name",
    get: function get() {
      return this._separate.name;
    }
  }, {
    key: "moduleName",
    get: function get() {
      return this._separate.moduleName;
    }
  }, {
    key: "path",
    get: function get() {
      return this._separate.path;
    }
  }, {
    key: "plain",
    get: function get() {
      return this._separate.plain;
    }
  }, {
    key: "ext",
    get: function get() {
      return this._separate.ext;
    }
  }, {
    key: "type",
    get: function get() {
      return this.props.type;
    }
  }, {
    key: "component",
    get: function get() {
      return this.props.component;
    }
  }, {
    key: "header",
    get: function get() {
      if (this.is('markdown')) {
        return this.text.trim() // 前後の空白を削除
        .replace(/\n[^]*$/, '') // 改行以降を削除
        .trim() // 前後の空白を削除
        .replace(/^[#-]*\s*/, '') // 行頭の # - を削除
        .replace(/[*~_[\]()`]/g, ''); // * ~ _ [] () `` を削除
      }

      return this.plain + this.ext;
    }
  }, {
    key: "credits",
    get: function get() {
      return this.props.credits instanceof Array ? this.props.credits : [];
    }
  }, {
    key: "sign",
    get: function get() {
      return this.props.sign;
    }
  }, {
    key: "credit",
    get: function get() {
      var _this3 = this;

      var credit = this.credits.find(function (item) {
        return item.hash === _this3.hash;
      });

      if (credit) {
        return credit;
      }

      return this.sign || null;
    }
  }, {
    key: "isTrashed",
    get: function get() {
      return !!this.options.isTrashed;
    }
  }, {
    key: "error",
    get: function get() {
      throw 'file.error is unsupported';
    }
  }, {
    key: "lastModified",
    get: function get() {
      return this.props.lastModified || 0;
    }
  }]);
  return _File;
}();

exports.default = _File;
(0, _defineProperty2.default)(_File, "defaultProps", {});
(0, _defineProperty2.default)(_File, "defaultOptions", {});
(0, _defineProperty2.default)(_File, "visible", ['name', 'moduleName', 'type', 'lastModified', 'options', 'credits', 'sign']);
(0, _defineProperty2.default)(_File, "_dataURLCache", new WeakMap());
(0, _defineProperty2.default)(_File, "_babelCache", new WeakMap());

var getUniqueId = function (i) {
  return function () {
    return '_File__' + ++i;
  };
}(0);