ldx-widgets/dist/mixins/input_mixin.js

widgets

(function() {
  var ENTER, ReactDOM, _, makeGuid;

  ReactDOM = require('react-dom');

  _ = require('lodash');

  makeGuid = require('../utils').makeGuid;

  ENTER = require('../constants/keyboard').ENTER;

  module.exports = {
    getInitialState: function() {
      return {
        valueHasChanged: false
      };
    },
    componentWillMount: function() {
      var isInPopover;
      isInPopover = this.props.isInPopover;
      this.inputId = makeGuid();
      if (isInPopover) {
        return this.trigger('raiseValidation');
      } else {
        return this.trigger('lowerValidation');
      }
    },
    componentDidMount: function() {
      var focusOnMount, ref, validation, value;
      ref = this.props, value = ref.value, validation = ref.validation, focusOnMount = ref.focusOnMount;
      this.validate(validation, value);
      if (focusOnMount) {
        return this.focus();
      }
    },
    componentWillReceiveProps: function(nextProps) {
      var ref, validation, validationChanged, value;
      value = nextProps.value, validation = nextProps.validation;
      validationChanged = (typeof validation === 'function' ? false : !_.isEqual(validation != null ? validation.messages : void 0, (ref = this.props.validation) != null ? ref.messages : void 0));
      if (validationChanged) {
        return this.validate(validation, value);
      }
    },
    componentWillUnmount: function() {
      return this.trigger('clearValidationError', this.inputId);
    },
    handleChange: function(e) {
      var onChange, ref, validation, value, valueHasChanged;
      value = e.target.value;
      ref = this.props, onChange = ref.onChange, validation = ref.validation;
      valueHasChanged = this.state.valueHasChanged;
      if (!valueHasChanged) {
        this.setState({
          valueHasChanged: true
        });
      }
      this.validate(validation, value);
      if (typeof onChange === "function") {
        onChange(value);
      }
      return this.fireDelayedAction();
    },
    fireDelayedAction: function() {
      var action, delayedActionOnChange, interval, ref, value;
      ref = this.props, delayedActionOnChange = ref.delayedActionOnChange, value = ref.value;
      if (delayedActionOnChange != null) {
        action = delayedActionOnChange.action, interval = delayedActionOnChange.interval;
        clearInterval(this.delayedActionTimer);
        return this.delayedActionTimer = setTimeout((function(_this) {
          return function() {
            return action(value);
          };
        })(this), interval);
      }
    },
    validate: function(validation, value) {
      var validationError;
      if (validation === false) {
        return;
      }
      if (typeof validation === 'function') {
        validationError = validation(value);
      } else {
        validationError = validation;
      }
      if (validationError != null) {
        return this.trigger('addValidationError', {
          anchor: this.refs.errorAnchor,
          error: validationError,
          groupId: this.inputId
        });
      } else {
        return this.trigger('clearValidationError', this.inputId);
      }
    },
    handleKeyUp: function(e) {
      var onEnterKey, onKeyUp, ref;
      ref = this.props, onEnterKey = ref.onEnterKey, onKeyUp = ref.onKeyUp;
      if (e.keyCode === ENTER) {
        if (typeof onEnterKey === "function") {
          onEnterKey(e);
        }
      }
      return typeof onKeyUp === "function" ? onKeyUp(e) : void 0;
    },
    getValue: function() {
      var value;
      value = (function(_this) {
        return function() {
          if (_this.refs.input.getValue != null) {
            return _this.refs.input.getValue();
          } else {
            return _this.refs.input.value;
          }
        };
      })(this)();
      if ((this.props.textTransform != null) && value) {
        value = this.props.textTransform(value);
      }
      return value;
    },
    clear: function() {
      return this.props.onChange('');
    },
    focus: function() {
      return ReactDOM.findDOMNode(this.refs.input).focus();
    },
    blur: function() {
      return ReactDOM.findDOMNode(this.refs.input).blur();
    },
    handleErrorMouseOver: function() {
      var ref, validation, value;
      ref = this.props, validation = ref.validation, value = ref.value;
      return this.trigger('toggleError', {
        groupId: this.inputId,
        status: true,
        isMouseOver: true
      });
    },
    handleErrorMouseOut: function() {
      return this.trigger('toggleError', {
        groupId: this.inputId,
        status: false,
        isMouseOver: true
      });
    }
  };

}).call(this);