"use strict";

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

var _Field = _interopRequireDefault(require("./Field"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _react = _interopRequireWildcard(require("react"));

var _Dropdown = _interopRequireDefault(require("../widgets/Dropdown"));

var _TextInput = _interopRequireDefault(require("../widgets/TextInput"));

var _lib = require("../../lib");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var operations = function operations(_) {
  return {
    inequality: [{
      value: '!=',
      label: _('Target ≠ Reference')
    }, {
      value: '<',
      label: _('Target < Reference')
    }, {
      value: '<=',
      label: _('Target ≤ Reference')
    }, {
      value: '=',
      label: _('Target = Reference')
    }, {
      value: '>',
      label: _('Target > Reference')
    }, {
      value: '>=',
      label: _('Target ≥ Reference')
    }],
    inrange: [{
      value: '[]',
      label: _('Lower ≤ Target ≤ Upper')
    }, {
      value: '()',
      label: _('Lower < Target < Upper')
    }, {
      value: '[)',
      label: _('Lower ≤ Target < Upper')
    }, {
      value: '(]',
      label: _('Lower < Target ≤ Upper')
    }],
    exrange: [{
      value: ')(',
      label: _('Lower ≤ Target ≤ Upper')
    }, {
      value: '][',
      label: _('Lower < Target < Upper')
    }, {
      value: ')[',
      label: _('Lower ≤ Target < Upper')
    }, {
      value: '](',
      label: _('Lower < Target ≤ Upper')
    }],
    inset: [{
      value: '{}',
      label: _('Include')
    }],
    exset: [{
      value: '}{',
      label: _('Exclude')
    }]
  };
};

var findOperation = function findOperation(operator, _) {
  var op = 'inequality';
  var ops = operations(_);

  for (var key in ops) {
    if (ops.hasOwnProperty(key) && ops[key].map(function (o) {
      return o.value;
    }).indexOf(operator) !== -1) {
      op = key;
      break;
    }
  }

  return op;
};

var UnconnectedFilterOperation =
/*#__PURE__*/
function (_Component) {
  _inherits(UnconnectedFilterOperation, _Component);

  function UnconnectedFilterOperation(props, context) {
    var _this;

    _classCallCheck(this, UnconnectedFilterOperation);

    _this = _possibleConstructorReturn(this, _getPrototypeOf(UnconnectedFilterOperation).call(this, props, context));
    var _ = context.localize;
    _this.state = {
      operation: findOperation(_this.props.fullValue, _),
      operator: operations(_).inequality[0].value
    };
    _this.setOperation = _this.setOperation.bind(_assertThisInitialized(_this));
    return _this;
  }

  _createClass(UnconnectedFilterOperation, [{
    key: "setOperation",
    value: function setOperation(value) {
      var _ = this.context.localize;
      var operator = operations(_)[value][0].value;
      this.setState({
        operation: value,
        operator: operator
      });
      this.props.updatePlot(operator);
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
          fullValue = _this$props.fullValue,
          updatePlot = _this$props.updatePlot,
          backgroundDark = _this$props.backgroundDark,
          attr = _this$props.attr;
      var _ = this.context.localize;
      var operators = [{
        label: _('Inequality'),
        value: 'inequality'
      }, {
        label: _('Include Range'),
        value: 'inrange'
      }, {
        label: _('Exclude Range'),
        value: 'exrange'
      }, {
        label: _('Include Values'),
        value: 'inset'
      }, {
        label: _('Exclude Values'),
        value: 'exset'
      }];
      var opValue = fullValue && fullValue.length > 0 ? fullValue : this.state.operator;
      return _react.default.createElement("div", null, _react.default.createElement(_Field.default, _extends({}, this.props, {
        attr: attr
      }), _react.default.createElement(_Dropdown.default, {
        backgroundDark: backgroundDark,
        options: operators,
        value: findOperation(opValue, _),
        onChange: this.setOperation,
        clearable: false
      }), this.state.operation === 'inset' || this.state.operation === 'exset' ? null : _react.default.createElement(_Dropdown.default, {
        backgroundDark: backgroundDark,
        options: operations(_)[this.state.operation],
        value: opValue,
        onChange: updatePlot,
        clearable: false
      })));
    }
  }]);

  return UnconnectedFilterOperation;
}(_react.Component);

UnconnectedFilterOperation.propTypes = _objectSpread({
  fullValue: _propTypes.default.any,
  updatePlot: _propTypes.default.func
}, _Field.default.propTypes);
UnconnectedFilterOperation.contextTypes = {
  localize: _propTypes.default.func
};

var UnconnectedFilterValue =
/*#__PURE__*/
function (_Component2) {
  _inherits(UnconnectedFilterValue, _Component2);

  function UnconnectedFilterValue(props, context) {
    var _this2;

    _classCallCheck(this, UnconnectedFilterValue);

    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(UnconnectedFilterValue).call(this, props, context));
    _this2.state = {
      value: '',
      valueMax: ''
    };
    _this2.setValue = _this2.setValue.bind(_assertThisInitialized(_this2));
    _this2.setValueMax = _this2.setValueMax.bind(_assertThisInitialized(_this2));
    return _this2;
  }

  _createClass(UnconnectedFilterValue, [{
    key: "setValue",
    value: function setValue(v) {
      var _this$context = this.context,
          _ = _this$context.localize,
          container = _this$context.container;
      var op = findOperation(container.operation, _);
      this.setState({
        value: v
      });
      var val;
      val = op === 'inrange' || op === 'exrange' ? [v, this.state.valueMax] : v;

      if (op === 'inset' || op === 'exset') {
        val = val.split(',');
        val = val.map(function (v) {
          return v.trim();
        });
      }

      this.props.updatePlot(val);
    }
  }, {
    key: "setValueMax",
    value: function setValueMax(v) {
      this.setState({
        valueMax: v
      });
      this.props.updatePlot([this.state.value, v]);
    }
  }, {
    key: "render",
    value: function render() {
      var _this$context2 = this.context,
          _ = _this$context2.localize,
          container = _this$context2.container;
      var operation = container && container.operation ? container.operation : '=';
      var _this$props2 = this.props,
          fullValue = _this$props2.fullValue,
          attr = _this$props2.attr,
          defaultValue = _this$props2.defaultValue;
      var op = findOperation(operation, _);

      var label1 = _('Reference');

      if (op === 'inrange' || op === 'exrange') {
        label1 = _('Lower Bound');
      } else if (op === 'inset' || op === 'exset') {
        label1 = _('Values');
      }

      var val1 = fullValue;

      if ((op === 'inset' || op === 'exset') && Array.isArray(fullValue)) {
        val1 = fullValue.join(', ');
      } else if (Array.isArray(fullValue)) {
        val1 = fullValue[0];
      }

      return _react.default.createElement("div", null, _react.default.createElement(_Field.default, _extends({}, this.props, {
        label: label1
      }), _react.default.createElement(_TextInput.default, {
        value: val1,
        defaultValue: val1,
        onUpdate: this.setValue
      })), !(op === 'inrange' || op === 'exrange') ? null : _react.default.createElement(_Field.default, _extends({}, this.props, {
        label: _('Upper Bound'),
        attr: attr
      }), _react.default.createElement(_TextInput.default, {
        value: Array.isArray(fullValue) ? fullValue[1] : fullValue,
        defaultValue: defaultValue,
        onUpdate: this.setValueMax
      })));
    }
  }]);

  return UnconnectedFilterValue;
}(_react.Component);

UnconnectedFilterValue.propTypes = _objectSpread({
  defaultValue: _propTypes.default.string,
  fullValue: _propTypes.default.any,
  updatePlot: _propTypes.default.func
}, _Field.default.propTypes);
UnconnectedFilterValue.contextTypes = {
  localize: _propTypes.default.func,
  container: _propTypes.default.object
};
var FilterOperation = (0, _lib.connectToContainer)(UnconnectedFilterOperation);
exports.FilterOperation = FilterOperation;
var FilterValue = (0, _lib.connectToContainer)(UnconnectedFilterValue);
exports.FilterValue = FilterValue;
//# sourceMappingURL=FilterOperation.js.map