@thewtex/vtk.js-esm/Widgets/Core/StateBuilder.js

Visualization Toolkit for the Web

import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
import _createClass from '@babel/runtime/helpers/createClass';
import macro from '../../macro.js';
import vtkWidgetState from './WidgetState.js';
import bounds from './StateBuilder/boundsMixin.js';
import color from './StateBuilder/colorMixin.js';
import corner from './StateBuilder/cornerMixin.js';
import direction from './StateBuilder/directionMixin.js';
import manipulator from './StateBuilder/manipulatorMixin.js';
import name from './StateBuilder/nameMixin.js';
import orientation from './StateBuilder/orientationMixin.js';
import origin from './StateBuilder/originMixin.js';
import scale1 from './StateBuilder/scale1Mixin.js';
import scale3 from './StateBuilder/scale3Mixin.js';
import text from './StateBuilder/textMixin.js';
import visible from './StateBuilder/visibleMixin.js';
import shape from './StateBuilder/shapeMixin.js';

var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
// Global type lookup map
// ----------------------------------------------------------------------------

var MIXINS = {
  bounds: bounds,
  color: color,
  corner: corner,
  direction: direction,
  manipulator: manipulator,
  name: name,
  orientation: orientation,
  origin: origin,
  scale1: scale1,
  scale3: scale3,
  text: text,
  visible: visible,
  shape: shape
}; // ----------------------------------------------------------------------------

function newInstance(mixins, initialValues) {
  var publicAPI = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  var model = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var skipWidgetState = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;

  if (!skipWidgetState) {
    vtkWidgetState.extend(publicAPI, model, initialValues);
  }

  for (var i = 0; i < mixins.length; i++) {
    var mixin = MIXINS[mixins[i]];

    if (mixin) {
      mixin.extend(publicAPI, model, initialValues);
    } else {
      vtkErrorMacro('Invalid mixin name:', mixins[i]);
    }
  }

  macro.safeArrays(model);
  return Object.freeze(publicAPI);
} // ----------------------------------------------------------------------------


var Builder = /*#__PURE__*/function () {
  function Builder() {
    _classCallCheck(this, Builder);

    this.publicAPI = {};
    this.model = {};
    vtkWidgetState.extend(this.publicAPI, this.model); // The root state should always have the bounds/placeWidget/widgetFactor

    bounds.extend(this.publicAPI, this.model);
  }
  /* eslint-disable no-shadow */


  _createClass(Builder, [{
    key: "addDynamicMixinState",
    value: function addDynamicMixinState(_ref) {
      var _this = this;

      var labels = _ref.labels,
          mixins = _ref.mixins,
          name = _ref.name,
          initialValues = _ref.initialValues;
      var listName = "".concat(name, "List");
      this.model[listName] = []; // Create new Instance method

      this.publicAPI["add".concat(macro.capitalize(name))] = function () {
        var instance = newInstance(mixins, initialValues);

        _this.publicAPI.bindState(instance, labels);

        _this.model[listName].push(instance);

        _this.publicAPI.modified();

        return instance;
      };

      this.publicAPI["remove".concat(macro.capitalize(name))] = function (instanceOrIndex) {
        var removeIndex = _this.model[listName].indexOf(instanceOrIndex);

        if (removeIndex === -1 && instanceOrIndex < _this.model[listName].length) {
          removeIndex = instanceOrIndex;
        }

        var instance = _this.model[listName][removeIndex];

        if (instance) {
          _this.publicAPI.unbindState(instance);
        }

        _this.model[listName].splice(removeIndex, 1);

        _this.publicAPI.modified();
      };

      this.publicAPI["get".concat(macro.capitalize(name), "List")] = function () {
        return _this.model[listName].slice();
      };

      this.publicAPI["clear".concat(macro.capitalize(name), "List")] = function () {
        while (_this.model[listName].length) {
          var instance = _this.model[listName].pop();

          if (instance) {
            _this.publicAPI.unbindState(instance);
          }
        }

        _this.publicAPI.modified();
      };

      return this;
    }
  }, {
    key: "addStateFromMixin",
    value: function addStateFromMixin(_ref2) {
      var labels = _ref2.labels,
          mixins = _ref2.mixins,
          name = _ref2.name,
          initialValues = _ref2.initialValues;
      var instance = newInstance(mixins, initialValues);
      this.model[name] = instance;
      this.publicAPI.bindState(instance, labels);
      macro.setGet(this.publicAPI, this.model, [name]);
      return this;
    }
  }, {
    key: "addStateFromInstance",
    value: function addStateFromInstance(_ref3) {
      var labels = _ref3.labels,
          name = _ref3.name,
          instance = _ref3.instance;
      this.model[name] = instance;
      this.publicAPI.bindState(instance, labels);
      macro.setGet(this.publicAPI, this.model, [name]);
      return this;
    }
  }, {
    key: "addField",
    value: function addField(_ref4) {
      var name = _ref4.name,
          initialValue = _ref4.initialValue;

      if (Array.isArray(initialValue)) {
        macro.setGetArray(this.publicAPI, this.model, [name], initialValue.length);
      } else {
        macro.setGet(this.publicAPI, this.model, [name]);
      }

      this.model[name] = initialValue;
      return this;
    }
  }, {
    key: "build",
    value: function build() {
      for (var _len = arguments.length, mixins = new Array(_len), _key = 0; _key < _len; _key++) {
        mixins[_key] = arguments[_key];
      }

      return newInstance(mixins, {}, this.publicAPI, this.model, true);
    }
  }]);

  return Builder;
}(); // ----------------------------------------------------------------------------
// Public API
// ----------------------------------------------------------------------------


function createBuilder() {
  return new Builder();
}
var vtkStateBuilder = {
  createBuilder: createBuilder
};

export default vtkStateBuilder;
export { createBuilder };