ten-design-vue/lib/input/value-format.js

ten-vue

"use strict";

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

var _input = _interopRequireDefault(require("./input"));

var _excluded = ["input", "change"];

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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

function valueFormat() {
  return {
    inheritAttrs: false,
    model: {
      prop: 'value',
      event: 'change'
    },
    props: {
      parser: {
        type: [Array, Function, Object]
      },
      formatter: {
        type: [Array, Function, Object]
      },
      value: {
        validator: function validator() {
          return true;
        }
      },
      isChanged: {
        type: Function,
        default: function _default(a, b) {
          return a !== b;
        }
      }
    },
    data: function data() {
      return {
        dataValue: undefined
      };
    },
    watch: {
      value: {
        immediate: true,
        handler: function handler(value) {
          this.dataValue = this.handler('formatter', value);
        }
      }
    },
    methods: {
      handler: function handler(type, value, isInputing) {
        if (!(value != null)) return; // eslint-disable-line

        var handler = this[type];

        if (!Array.isArray(handler)) {
          handler = [handler];
        }

        handler.forEach(function (rule) {
          if (typeof rule === 'function' && !isInputing) {
            value = rule(value);
          } else if (rule.handler && (!isInputing || rule.input)) {
            value = rule.handler(value);
          }
        });
        return value;
      },
      transform: function transform(value, isInputing) {
        var propValue = this.handler('parser', value, isInputing);
        var inputValue = this.handler('formatter', propValue, isInputing);
        return {
          propValue: propValue,
          inputValue: inputValue
        };
      },
      onChange: function onChange() {
        var _this$transform = this.transform(this.dataValue),
            inputValue = _this$transform.inputValue,
            propValue = _this$transform.propValue;

        if (this.isChanged(propValue, this.value)) {
          this.$emit('change', propValue);
        } else if (this.dataValue !== inputValue) {
          this.dataValue = inputValue;
        }
      },
      onInput: function onInput(value) {
        var _this$transform2 = this.transform(value, true),
            inputValue = _this$transform2.inputValue;

        this.dataValue = inputValue;
        this.$emit('input', this.dataValue);
      }
    },
    render: function render(h) {
      var _this$$listeners = this.$listeners,
          input = _this$$listeners.input,
          change = _this$$listeners.change,
          othersEvent = _objectWithoutProperties(_this$$listeners, _excluded);

      return h(_input.default, {
        on: _objectSpread({
          input: this.onInput,
          change: this.onChange
        }, othersEvent),
        props: _objectSpread(_objectSpread({}, this.$attrs), {}, {
          value: this.dataValue
        }),
        scopedSlots: _objectSpread({}, this.$scopedSlots),
        ref: 'refInputElm'
      });
    }
  };
}

var _default2 = valueFormat;
exports.default = _default2;