awv3/plugins/interpreter/index.js

⚡ AWV3 embedded CAD

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
import _extends from "@babel/runtime/helpers/extends";
import Plugin from '../../session/plugin';
import { Button, Input, Label, Checkbox, Group } from '../../session/elements';
var resources = ['isometric'].reduce(function (prev, item) {
  var _extends2;

  return _extends({}, prev, (_extends2 = {}, _extends2[item] = require('!!url-loader!awv3-icons/32x32/' + item + '.png'), _extends2));
}, {});

function setResults(label, results) {
  label.value = results.reduce(function (text, result) {
    text = result.errors.reduce(function (t, e) {
      return t + e.errorMessage + '\n';
    }, text);
    return result.results.reduce(function (t, r) {
      return t + r.result + '\n';
    }, text);
  }, '');
}

var Interpreter =
/*#__PURE__*/
function (_Plugin) {
  _inheritsLoose(Interpreter, _Plugin);

  function Interpreter(session, args) {
    var _this;

    _this = _Plugin.call(this, session, _extends({
      type: 'Interpreter',
      icon: 'isometric',
      resources: resources,
      text: ''
    }, args)) || this;
    _this.chunks = true;
    _this.sequence = new Checkbox(_assertThisInitialized(_this), {
      name: 'Sequence',
      value: _this.chunks
    });

    _this.addElement(new Group(_assertThisInitialized(_this), {
      format: Group.Format.Table,
      children: [_this.sequence]
    }));

    _this.input = new Input(_assertThisInitialized(_this), {
      name: 'Command',
      value: _this.text,
      format: Input.Format.MultiLine,
      style: {
        fontSize: '0.8em',
        fontFamily: 'monospace'
      }
    });

    _this.addElement(_this.input);

    _this.label = new Label(_assertThisInitialized(_this), {
      name: 'Result',
      value: ''
    });

    _this.addElement(_this.label);

    _this.okButton = new Button(_assertThisInitialized(_this), {
      name: 'Execute'
    });
    _this.clearButton = new Button(_assertThisInitialized(_this), {
      name: 'Clear'
    });

    _this.addElement(new Group(_assertThisInitialized(_this), {
      format: Group.Format.Buttons,
      children: [_this.clearButton, _this.okButton]
    }));

    return _this;
  }

  var _proto = Interpreter.prototype;

  _proto.onEnabled = function onEnabled() {
    var _this2 = this;

    this.resetElements();
    this.clearButton.observe(function (state) {
      return state.lastEvent;
    }, function (event) {
      _this2.session.activeConnectionClass.execute('_O.ToolBuilder.Clear();');
    });
    this.okButton.observe(function (state) {
      return state.lastEvent;
    },
    /*#__PURE__*/
    function () {
      var _ref = _asyncToGenerator(
      /*#__PURE__*/
      _regeneratorRuntime.mark(function _callee(event) {
        var results;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                console.time('INTERPRETER');

                if (!_this2.chunks) {
                  _context.next = 7;
                  break;
                }

                _context.next = 4;
                return Promise.all(_this2.input.value.split(';').filter(function (e) {
                  return e;
                }).map(function (command) {
                  return command.length && _this2.session.activeConnectionClass.execute(command + ';');
                }));

              case 4:
                results = _context.sent;
                _context.next = 11;
                break;

              case 7:
                _context.next = 9;
                return _this2.session.activeConnectionClass.execute(_this2.input.value);

              case 9:
                _context.t0 = _context.sent;
                results = [_context.t0];

              case 11:
                _this2.connection.updateView();

                _this2.view.controls.focus().zoom();

                console.timeEnd('INTERPRETER');
                setResults(_this2.label, results);

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

      return function (_x) {
        return _ref.apply(this, arguments);
      };
    }());
    this.sequence.observe(function (state) {
      return state.value;
    }, function (value) {
      return _this2.chunks = value;
    });
  };

  return Interpreter;
}(Plugin);

export { Interpreter as default };