polestar-ui-kit/lib/SchemaForm/helpers/FormHelpers.js

## Install

"use strict";

require("core-js/modules/es.array.concat");

require("core-js/modules/es.array.filter");

require("core-js/modules/es.array.for-each");

require("core-js/modules/es.array.is-array");

require("core-js/modules/es.array.map");

require("core-js/modules/es.array.splice");

require("core-js/modules/es.function.name");

require("core-js/modules/es.object.assign");

require("core-js/modules/es.object.define-property");

require("core-js/modules/es.object.keys");

require("core-js/modules/web.dom-collections.for-each");

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

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

var _antd = require("antd");

var _datePicker = _interopRequireDefault(require("antd/lib/date-picker"));

var _moment = _interopRequireDefault(require("moment"));

var _GroupHeader = _interopRequireDefault(require("../GroupHeader"));

var _Button = _interopRequireDefault(require("../../Button"));

var _Divider = _interopRequireDefault(require("../../Divider"));

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

var _checkMaxBytes = _interopRequireDefault(require("./checkMaxBytes"));

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

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 _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; }

var FormItem = _antd.Form.Item;
var MonthPicker = _datePicker["default"].MonthPicker;
var COMPONENT_FIELD_TYPES = {
  text: _Field.Input,
  id: _Field.IDInput,
  password: _Field.PasswordInput,
  email: _Field.EmailInput,
  ip: _Field.IPInput,
  textarea: _Field.TextArea,
  numeric: _Field.InputNumber,
  select: _Field.Select,
  checkbox: _Field.Checkbox,
  radio: _Field.RadioGroup,
  datepicker: _Field.DatePicker,
  daterangepicker: _Field.DateRangePicker,
  basedatepicker: _Field.BaseDatePicker,
  timepicker: _Field.TimePicker,
  upload: _Field.Upload,
  cascader: _Field.Cascader,
  slider: _Field.Slider,
  rate: _Field.Rate,
  treeselect: _Field.TreeSelect,
  gridtogrid: _Field.GridToGrid
};

var FormHelpers = function () {
  function FormHelpers(_component, form, parent) {
    var _this = this;

    _classCallCheck(this, FormHelpers);

    this.create = function (schema) {
      var formData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var render = [];
      var fields = schema.fields;

      if (Array.isArray(fields)) {
        fields.forEach(function (groups, index) {
          render.push(_this._generateGroups(groups, formData));

          if (index < fields.length - 1) {
            render.push(_react["default"].createElement(_Divider["default"], {
              key: _this._getDividerIndex()
            }));
          }
        });
      } else {
        render.push(_this._renderFields(fields.properties, fields.ui, formData));

        if (fields.title) {
          var groupHeader = _react["default"].createElement(_GroupHeader["default"], {
            id: fields.title,
            key: "group-".concat(_this._getGroupIndex())
          }, fields.title);

          render.splice(0, 0, groupHeader);
        }
      }

      return {
        render: render,
        labelFields: _this.labelFields
      };
    };

    this._getRenderIndex = function () {
      return ++_this.renderIndex;
    };

    this._getGroupIndex = function () {
      return ++_this.groupIndex;
    };

    this._getRowIndex = function () {
      return ++_this.rowIndex;
    };

    this._getColIndex = function () {
      _this.colIndex += 1;
      return "".concat(_this.rowIndex, "_").concat(_this.colIndex);
    };

    this._getDividerIndex = function () {
      return ++_this.dividerIndex;
    };

    this._generateGroups = function (groups, formData) {
      var rowRender = [];
      var colRender = [];

      var avgSpan = _this._calculateAvgSpan(groups);

      groups.forEach(function (groupProps) {
        var renderFields = _this._renderFields(groupProps.properties, groupProps.ui, formData);

        if (groupProps.title) {
          var groupHeader = _react["default"].createElement(_GroupHeader["default"], {
            id: groupProps.title,
            key: "group-".concat(_this._getGroupIndex())
          }, groupProps.title);

          renderFields.splice(0, 0, groupHeader);
        }

        colRender.push(_this._renderCol("col-".concat(_this._getColIndex()), groupProps.span || avgSpan, renderFields));
      });
      rowRender.push(_this._renderRow('groups-row', colRender));
      return rowRender;
    };

    this._renderFields = function (properties) {
      var ui = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var formData = arguments.length > 2 ? arguments[2] : undefined;
      var render = [];

      if (Array.isArray(properties)) {
        properties.forEach(function (colProperties) {
          render.push(_this._generateFields(colProperties, ui, formData, true));
        });
      } else {
        render.push(_this._generateFields(properties, ui, formData, false));
      }

      return render;
    };

    this._calculateAvgSpan = function (properties) {
      var ui = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var hiddenCount = 0;
      var countSpan = 0;
      var sumSpan = 0;
      var avgSpan = 0;
      var fieldNames = Object.keys(properties);
      fieldNames.forEach(function (key) {
        var mergeProps = Object.assign(properties[key], ui[key] || {});

        if (mergeProps.renderType === 'hidden') {
          hiddenCount += 1;
        } else if (properties[key].span) {
          countSpan += 1;
          sumSpan += properties[key].span;
        }
      });
      var remainSpan = fieldNames.length - (countSpan + hiddenCount);

      if (remainSpan > 0) {
        avgSpan = Math.floor((_this.defaultConfig.layout.rowSpan - sumSpan) / remainSpan);
      }

      return avgSpan;
    };

    this._renderRow = function (key, children) {
      return _react["default"].createElement(_antd.Row, {
        key: key,
        gutter: _this.defaultConfig.layout.rowGutter
      }, children);
    };

    this._renderCol = function (key, span, children, fieldStyle) {
      return _react["default"].createElement(_antd.Col, {
        key: key,
        span: span,
        style: fieldStyle
      }, children);
    };

    this._createFormItem = function (key, mergeProps, renderField, formData) {
      if (renderField) {
        if (mergeProps.renderType === 'custom') {
          return renderField;
        }

        var _mergeProps$addFields = mergeProps.addFields,
            addFields = _mergeProps$addFields === void 0 ? false : _mergeProps$addFields,
            extend = mergeProps.extend;
        var renderAddFieldsButton = null;

        if (addFields) {
          var addKey = "add-".concat(key);
          renderAddFieldsButton = addFields ? _this._generateAddFieldButton(addKey, key, formData, extend) : null;

          var keys = _this.form.getFieldValue(addKey);

          if (keys.length >= 0) {
            return keys.map(function (keyIndex) {
              var renderExtends = _this._generateExtend(mergeProps, renderField, renderAddFieldsButton, formData, keyIndex, addKey);

              return _this._renderFormItem(mergeProps, {
                key: key,
                renderField: renderField,
                renderExtends: renderExtends
              }, formData, keyIndex);
            });
          }
        }

        var renderExtends = _this._generateExtend(mergeProps, renderField, renderAddFieldsButton, formData, 0);

        return _this._renderFormItem(mergeProps, {
          key: key,
          renderField: renderField,
          renderExtends: renderExtends
        }, formData, 0);
      }

      return _react["default"].createElement("div", null, mergeProps.label, ": \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 UI \uB610\uB294 \uC18D\uC131 \uC785\uB2C8\uB2E4. API\uB97C \uD655\uC778\uD574\uC8FC\uC138\uC694.");
    };

    this._getFieldDecoratorOption = function (key, itemIndex, mergeProps, formData, addFields, extend) {
      var checkDecorator;

      if (mergeProps.renderType === 'checkbox') {
        checkDecorator = {
          valuePropName: 'checked'
        };
      }

      return _extends({
        rules: _this._setValidateRules(mergeProps)
      }, checkDecorator, {
        initialValue: _this._convertValue(key, itemIndex, formData, mergeProps, addFields, extend)
      });
    };

    this._setValidateRules = function (mergeProps) {
      var rules = [];
      var renderType = mergeProps.renderType,
          required = mergeProps.required,
          requiredMessage = mergeProps.requiredMessage,
          minLength = mergeProps.minLength,
          maxLength = mergeProps.maxLength,
          maxBytes = mergeProps.maxBytes,
          validator = mergeProps.validator;

      if (required) {
        rules.push({
          required: required,
          message: requiredMessage || _this.defaultConfig.validate.defaultMessage
        });
      }

      if (minLength !== undefined) {
        rules.push({
          min: mergeProps.minLength,
          message: "".concat(mergeProps.minLength, "\uC790 \uC774\uC0C1 \uC785\uB825\uD558\uC138\uC694.")
        });
      }

      if (maxLength !== undefined) {
        rules.push({
          max: maxLength,
          message: "".concat(maxLength, "\uC790 \uC774\uD558\uB85C \uC785\uB825\uD558\uC138\uC694.")
        });
      }

      if (maxBytes !== undefined) {
        rules.push({
          validator: _checkMaxBytes["default"],
          maxBytes: mergeProps.maxBytes
        });
      }

      if (validator !== undefined) {
        if (Array.isArray(validator)) {
          validator.forEach(function (_validator) {
            rules.push({
              validator: _validator
            });
          });
        } else {
          rules.push({
            validator: validator
          });
        }
      } else if (COMPONENT_FIELD_TYPES[renderType] && COMPONENT_FIELD_TYPES[renderType].validator) {
        if (!((renderType === 'text' || renderType === 'textarea') && maxBytes !== undefined)) {
          rules.push({
            validator: COMPONENT_FIELD_TYPES[renderType].validator
          });
        }
      }

      return rules;
    };

    this._renderFormItem = function (mergeProps, itemProps, formData, itemIndex) {
      var getFieldDecorator = _this.form.getFieldDecorator;
      var key = itemProps.key,
          renderField = itemProps.renderField,
          renderExtends = itemProps.renderExtends;
      var label = mergeProps.label,
          help = mergeProps.help,
          innerSpan = mergeProps.innerSpan,
          _mergeProps$addFields2 = mergeProps.addFields,
          addFields = _mergeProps$addFields2 === void 0 ? false : _mergeProps$addFields2,
          extend = mergeProps.extend;
      var itemKey = addFields ? "".concat(key, "[").concat(itemIndex, "]") : key;
      _this.labelFields[itemKey] = label;
      return _react["default"].createElement(FormItem, {
        label: itemIndex === 0 ? label : '',
        extra: itemIndex === 0 ? help : '',
        key: "".concat(key).concat(itemIndex)
      }, _react["default"].createElement(_antd.Row, {
        gutter: 10
      }, _react["default"].createElement(_antd.Col, {
        span: renderExtends ? innerSpan || renderExtends.avgSpan : _this.defaultConfig.layout.rowSpan
      }, getFieldDecorator(itemKey, _this._getFieldDecoratorOption(key, itemIndex, mergeProps, formData, addFields, extend))(renderField)), renderExtends ? renderExtends.render : null));
    };

    this._generateAddFieldButton = function (addKey, key, formData, extend) {
      var getFieldDecorator = _this.form.getFieldDecorator;
      var initialValue = [0];
      var valueArray = formData && formData[key] || [];

      if (extend) {
        valueArray = formData && formData[extend.name];
      }

      if (Array.isArray(valueArray) && valueArray.length > 0) {
        initialValue = valueArray.map(function (item, index) {
          return index;
        });
      }

      getFieldDecorator(addKey, {
        initialValue: initialValue
      });
      getFieldDecorator("".concat(addKey, "-index"), {
        initialValue: initialValue.length - 1
      });
      return _react["default"].createElement(_Button["default"].Add, {
        key: "button-".concat(_this._getRenderIndex()),
        onClick: function onClick() {
          _this._onAddFields(addKey);
        }
      });
    };

    this._onAddFields = function (addKey) {
      var _this$form$setFieldsV;

      var keys = _this.form.getFieldValue(addKey);

      var keyIndex = _this.form.getFieldValue("".concat(addKey, "-index"));

      var nextKeyIndex = keyIndex + 1;
      var nextKeys = keys.concat(nextKeyIndex);

      _this.form.setFieldsValue((_this$form$setFieldsV = {}, _defineProperty(_this$form$setFieldsV, addKey, nextKeys), _defineProperty(_this$form$setFieldsV, "".concat(addKey, "-index"), nextKeyIndex), _this$form$setFieldsV));
    };

    this._generateRemoveFieldButton = function (addKey, addKeyIndex) {
      return _react["default"].createElement(_Button["default"], {
        key: "button-".concat(_this._getRenderIndex()),
        icon: "minus-circled",
        onClick: function onClick() {
          _this._onRemoveFields(addKey, addKeyIndex);
        }
      }, _this.defaultConfig.label.remove);
    };

    this._onRemoveFields = function (addKey, addKeyIndex) {
      var keys = _this.form.getFieldValue(addKey);

      if (keys.length === 1) {
        return;
      }

      _this.form.setFieldsValue(_defineProperty({}, addKey, keys.filter(function (key) {
        return key !== addKeyIndex;
      })));
    };

    this._generateExtend = function (mergeProps, renderField, renderAddFieldsButton, formData, itemIndex) {
      var addKey = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
      var getFieldDecorator = _this.form.getFieldDecorator;
      var extend = mergeProps.extend,
          _mergeProps$innerSpan = mergeProps.innerSpan,
          innerSpan = _mergeProps$innerSpan === void 0 ? 0 : _mergeProps$innerSpan,
          _mergeProps$addFields3 = mergeProps.addFields,
          addFields = _mergeProps$addFields3 === void 0 ? false : _mergeProps$addFields3;
      var renderExtend = [];
      var renderButtons = [];
      var renderFields = [];
      var componentCount = 1;
      var isButton = false;

      if (extend && extend.fields) {
        var keys = Object.keys(extend.fields);
        keys.forEach(function (key) {
          var itemKey = addFields ? "".concat(key, "[").concat(itemIndex, "]") : key;
          var component = extend.fields[key];

          if (component.renderType && component.renderType === 'button') {
            isButton = true;
            var event = component.event || null;
            renderButtons.push(_react["default"].createElement(_Button["default"], {
              key: "button-".concat(_this._getRenderIndex()),
              icon: component.icon,
              onClick: function onClick() {
                if (event) {
                  event.onClick(itemIndex);
                }
              }
            }, component.label));
          } else {
            componentCount += 1;
            renderFields.push({
              key: "field-".concat(_this._getRenderIndex()),
              render: getFieldDecorator(itemKey, _this._getFieldDecoratorOption(key, itemIndex, component, formData, addFields, extend))(_this._generateField(component)),
              innerSpan: componentCount.innerSpan || 0
            });
          }
        });
      }

      if (renderAddFieldsButton != null) {
        isButton = true;

        if (itemIndex === 0) {
          renderButtons.push(renderAddFieldsButton);
        } else {
          renderButtons.push(_this._generateRemoveFieldButton(addKey, itemIndex));
        }
      }

      var avgSpan = (_this.defaultConfig.layout.rowSpan - innerSpan) / (isButton ? componentCount + 1 : componentCount);
      renderFields.forEach(function (field) {
        renderExtend.push(_react["default"].createElement(_antd.Col, {
          key: "field-".concat(_this._getRenderIndex()),
          span: field.innerSpan === 0 ? avgSpan : field.innerSpan
        }, _react["default"].createElement(FormItem, null, field.render)));
      });

      if (renderButtons.length > 0) {
        renderExtend.push(_react["default"].createElement(_antd.Col, {
          key: "inner-buttons-".concat(_this._getRenderIndex()),
          span: avgSpan
        }, _react["default"].createElement(_Button["default"].Spacing, {
          size: 10
        }, renderButtons)));
      }

      return {
        avgSpan: avgSpan,
        render: renderExtend
      };
    };

    this._generateFields = function () {
      var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var ui = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var formData = arguments.length > 2 ? arguments[2] : undefined;
      var isArray = arguments.length > 3 ? arguments[3] : undefined;
      var getFieldDecorator = _this.form.getFieldDecorator;
      var rowRender = [];
      var colRender = [];
      var avgSpan = 0;

      if (isArray) {
        avgSpan = _this._calculateAvgSpan(properties, ui);
      }

      var fieldNames = Object.keys(properties);
      fieldNames.forEach(function (key) {
        var mergeProps = Object.assign(properties[key], ui[key] || {});
        mergeProps.renderType = mergeProps.renderType || _this.defaultConfig.renderType[mergeProps.type];

        if (mergeProps.renderType === 'hidden') {
          getFieldDecorator(key, {
            initialValue: formData && formData[key] || mergeProps.defaultValue || null
          });
        } else {
          var formItem = _this._createFormItem(key, mergeProps, _this._generateField(mergeProps), formData);

          var fieldStyle = {};

          if (mergeProps.visible !== undefined && !mergeProps.visible) {
            fieldStyle.display = 'none';
          }

          if (isArray) {
            colRender.push(_this._renderCol("col-".concat(_this._getColIndex()), mergeProps.span || avgSpan, formItem, fieldStyle));
          } else {
            rowRender.push(_this._renderRow("row-".concat(_this._getRowIndex()), formItem));
          }
        }
      });

      if (isArray) {
        rowRender.push(_this._renderRow("row-".concat(_this._getRowIndex()), colRender));
      }

      return rowRender;
    };

    this._generateField = function (mergeProps) {
      var renderField;
      var renderType = mergeProps.renderType,
          autoFocus = mergeProps.autoFocus,
          readOnly = mergeProps.readOnly,
          disabled = mergeProps.disabled,
          _mergeProps$options = mergeProps.options,
          options = _mergeProps$options === void 0 ? {} : _mergeProps$options,
          _mergeProps$request = mergeProps.request,
          request = _mergeProps$request === void 0 ? {} : _mergeProps$request,
          className = mergeProps.className,
          _mergeProps$event = mergeProps.event,
          event = _mergeProps$event === void 0 ? {} : _mergeProps$event,
          items = mergeProps.items,
          lastPeriods = mergeProps.lastPeriods,
          placeholder = mergeProps.placeholder;

      var fieldProps = _extends({
        autoFocus: autoFocus,
        readOnly: readOnly,
        disabled: disabled,
        style: options ? options.style || {} : {},
        className: className
      }, event);

      switch (renderType) {
        case 'text':
          renderField = _react["default"].createElement(_Field.Input, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'textarea':
          renderField = _react["default"].createElement(_Field.TextArea, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'id':
          renderField = _react["default"].createElement(_Field.IDInput, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'password':
          renderField = _react["default"].createElement(_Field.PasswordInput, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'email':
          renderField = _react["default"].createElement(_Field.EmailInput, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'ip':
          renderField = _react["default"].createElement(_Field.IPInput, _extends({}, fieldProps, {
            placeholder: placeholder
          }, options));
          break;

        case 'select':
          renderField = _react["default"].createElement(_Field.Select, _extends({}, fieldProps, options, request, {
            items: items,
            placeholder: placeholder
          }));
          break;

        case 'checkbox':
          if (items) {
            renderField = _react["default"].createElement(_Field.CheckboxGroup, _extends({}, fieldProps, {
              options: items
            }));
          } else {
            renderField = _react["default"].createElement(_Field.Checkbox, _extends({}, fieldProps, options));
          }

          break;

        case 'radio':
          renderField = _react["default"].createElement(_Field.RadioGroup, _extends({}, fieldProps, options, {
            items: items
          }));
          break;

        case 'datepicker':
          renderField = _react["default"].createElement(_Field.DatePicker, _extends({}, fieldProps, options));
          break;

        case 'monthpicker':
          renderField = _react["default"].createElement(MonthPicker, fieldProps);
          break;

        case 'daterangepicker':
          renderField = _react["default"].createElement(_Field.DateRangePicker, _extends({}, fieldProps, options));
          break;

        case 'basedatepicker':
          renderField = _react["default"].createElement(_Field.BaseDatePicker, _extends({
            form: _this.form
          }, fieldProps, options, {
            lastPeriods: lastPeriods
          }));
          break;

        case 'timepicker':
          renderField = _react["default"].createElement(_Field.TimePicker, _extends({}, fieldProps, options));
          break;

        case 'numeric':
          renderField = _react["default"].createElement(_Field.InputNumber, _extends({}, fieldProps, options));
          break;

        case 'switch':
          renderField = _react["default"].createElement(_Field.Switch, _extends({}, fieldProps, options));
          break;

        case 'cascader':
          renderField = _react["default"].createElement(_Field.Cascader, _extends({}, fieldProps, options, {
            items: items,
            placeholder: placeholder
          }));
          break;

        case 'rate':
          renderField = _react["default"].createElement(_Field.Rate, fieldProps);
          break;

        case 'slider':
          renderField = _react["default"].createElement(_Field.Slider, _extends({}, fieldProps, options));
          break;

        case 'upload':
          renderField = _react["default"].createElement(_Field.Upload, _extends({
            form: _this.form
          }, fieldProps, options, {
            defaultFileList: mergeProps.defaultFileList
          }));
          break;

        case 'treeselect':
          renderField = _react["default"].createElement(_Field.TreeSelect, _extends({}, fieldProps, options, {
            placeholder: placeholder
          }));
          break;

        case 'gridtogrid':
          renderField = _react["default"].createElement(_Field.GridToGrid, _extends({}, fieldProps, options));
          break;

        default:
          renderField = null;
          break;
      }

      return renderField;
    };

    this.component = _component;
    this.form = form;
    this.parent = parent;
    this.labelFields = {};
    this.defaultConfig = {
      renderType: {
        string: 'text',
        number: 'numeric',
        "boolean": 'checkbox',
        array: 'checkbox'
      },
      layout: {
        rowSpan: 24,
        rowGutter: 20
      },
      datepicker: {
        format: 'YYYY-MM-DD'
      },
      validate: {
        defaultMessage: '필수 입력 항목입니다.'
      },
      label: {
        add: '추가',
        remove: '삭제'
      }
    };
    this.renderIndex = 1;
    this.groupIndex = 1;
    this.rowIndex = 1;
    this.colIndex = 1;
    this.dividerIndex = 1;
  }

  _createClass(FormHelpers, [{
    key: "_convertValue",
    value: function _convertValue(key, itemIndex, formData, mergeProps, addFields, extend) {
      var value;

      if (addFields) {
        var arrayValues;

        if (!extend) {
          arrayValues = formData && formData[key] || null;

          if (arrayValues && Array.isArray(arrayValues)) {
            value = arrayValues[itemIndex] || mergeProps.defaultValue || null;
          } else {
            value = mergeProps.defaultValue || null;
          }
        } else {
          arrayValues = formData && formData[extend.name] || null;

          if (arrayValues && Array.isArray(arrayValues) && arrayValues.length > 0 && arrayValues.length > itemIndex) {
            value = arrayValues[itemIndex][key] || mergeProps.defaultValue || null;
          } else {
            value = mergeProps.defaultValue || null;
          }
        }
      } else {
        value = formData && formData[key] || mergeProps.defaultValue || null;
      }

      if (value !== null && mergeProps.renderType) {
        if (mergeProps.renderType === 'datepicker') {
          value = (0, _moment["default"])(value, this.defaultConfig.datepicker.format);
        }
      }

      if (value === null) {
        if (mergeProps.renderType === 'select') {
          value = [];
        }
      }

      return value;
    }
  }]);

  return FormHelpers;
}();

var _default = FormHelpers;
exports["default"] = _default;