armo-breadboard/lib/WindowWrapper.js

Edit a live React component's source in real time.

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

exports.create = create;

var _fakeHistory = require('fake-history');

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function create() {
  // TODO: should be paused by default
  return new WindowWrapper();
}

var WindowWrapper = function () {
  function WindowWrapper(console) {
    var _this = this;

    _classCallCheck(this, WindowWrapper);

    this.seq = 1;

    this.timeouts = [];
    this.intervals = [];
    this.frames = [];

    this.window = {
      console: console,

      alert: window.alert,
      prompt: window.prompt,
      confirm: window.confirm,

      setTimeout: function setTimeout(cb, ms) {
        var id = window.setTimeout(cb, ms);
        _this.timeouts.push(id);
        return id;
      },

      setInterval: function setInterval(cb, ms) {
        var id = window.setInterval(cb, ms);
        _this.intervals.push(id);
        return id;
      },

      requestAnimationFrame: function requestAnimationFrame(cb) {
        var id = window.requestAnimationFrame(cb);
        _this.frames.push(id);
        return id;
      },

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

        var seq = _this.seq;
        return new Promise(function (resolve, reject) {
          var _window;

          return (_window = window).fetch.apply(_window, args).then(function () {
            if (seq === _this.seq) {
              resolve.apply(undefined, arguments);
            }
          }, function () {
            if (seq === _this.seq) {
              reject.apply(undefined, arguments);
            }
          });
        });
      },

      History: new _fakeHistory.FakeHistory()
    };
  }

  _createClass(WindowWrapper, [{
    key: 'eval',
    value: function _eval(source) {
      var _this2 = this;

      var globals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      var exports = {};
      var module = { exports: exports };
      var windowKeys = Object.keys(window);
      var globalKeys = Object.keys(globals);

      var execute = new (Function.prototype.bind.apply(Function, [null].concat(['window', 'module', 'exports'], _toConsumableArray(globalKeys), _toConsumableArray(windowKeys), [source])))();
      execute.apply(undefined, [window, module, exports].concat(_toConsumableArray(globalKeys.map(function (key) {
        return globals[key];
      })), _toConsumableArray(windowKeys.map(function (key) {
        return _this2.window[key];
      }))));

      var component = exports.default;

      return exports.default;
    }
  }, {
    key: 'reset',
    value: function reset() {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = this.timeouts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var timeout = _step.value;

          window.clearTimeout(timeout);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = this.intervals[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var interval = _step2.value;

          window.clearInterval(interval);
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

      try {
        for (var _iterator3 = this.frames[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var frame = _step3.value;

          window.cancelAnimationFrame(frame);
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3.return) {
            _iterator3.return();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }

      this.timeouts.length = 0;
      this.intervals.length = 0;
      this.frames.length = 0;

      this.window.console.clear();
      this.seq++;
    }
  }, {
    key: 'destroy',
    value: function destroy() {
      this.reset();
      this.window.console = null;
    }
  }]);

  return WindowWrapper;
}();

exports.default = WindowWrapper;