UNPKG

@form-create/ant-design-vue/dist/form-create.js

Version:
161 kBJavaScriptView Raw
1/*!
* @form-create/ant-design-vue v2.5.11
* (c) 2018-2021 xaboy
* Github https://github.com/xaboy/form-create
* Released under the MIT License.
*/
7(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('moment')) :
typeof define === 'function' && define.amd ? define(['exports', 'vue', 'moment'], factory) :
(global = global || self, factory(global.formCreate = {}, global.Vue, global.moment));
11}(this, (function (exports, Vue, moment) { 'use strict';
12
Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue;
moment = moment && Object.prototype.hasOwnProperty.call(moment, 'default') ? moment['default'] : moment;
15
function _extends() {
  return _extends = Object.assign || function (a) {
    for (var b, c = 1; c < arguments.length; c++) {
      for (var d in b = arguments[c], b) {
        Object.prototype.hasOwnProperty.call(b, d) && (a[d] = b[d]);
      }
    }
23
    return a;
  }, _extends.apply(this, arguments);
}
27
var normalMerge = ["attrs", "props", "domProps"],
    toArrayMerge = ["class", "style", "directives"],
    functionalMerge = ["on", "nativeOn"],
    mergeJsxProps = function mergeJsxProps(a) {
  return a.reduce(function (c, a) {
    for (var b in a) {
      if (!c[b]) c[b] = a[b];else if (-1 !== normalMerge.indexOf(b)) c[b] = _extends({}, c[b], a[b]);else if (-1 !== toArrayMerge.indexOf(b)) {
        var d = c[b] instanceof Array ? c[b] : [c[b]],
            e = a[b] instanceof Array ? a[b] : [a[b]];
        c[b] = d.concat(e);
      } else if (-1 !== functionalMerge.indexOf(b)) {
        for (var f in a[b]) {
          if (c[b][f]) {
            var g = c[b][f] instanceof Array ? c[b][f] : [c[b][f]],
                h = a[b][f] instanceof Array ? a[b][f] : [a[b][f]];
            c[b][f] = g.concat(h);
          } else c[b][f] = a[b][f];
        }
      } else if ("hook" == b) for (var i in a[b]) {
        c[b][i] = c[b][i] ? mergeFn(c[b][i], a[b][i]) : a[b][i];
      } else c[b] = a[b];
    }
50
    return c;
  }, {});
},
    mergeFn = function mergeFn(a, b) {
  return function () {
    a && a.apply(this, arguments), b && b.apply(this, arguments);
  };
};
59
var helper = mergeJsxProps;
61
function _typeof(obj) {
  "@babel/helpers - typeof";
64
  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }
74
  return _typeof(obj);
}
77
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
83
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;
  }
95
  return obj;
}
98
function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);
101
  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);
  }
109
  return keys;
}
112
function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};
116
    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }
129
  return target;
}
132
function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }
137
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}
147
function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}
154
function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
160
  return _setPrototypeOf(o, p);
}
163
function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;
168
  try {
    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}
176
function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }
181
  return self;
}
184
function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }
189
  return _assertThisInitialized(self);
}
192
function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();
195
  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived),
        result;
199
    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor;
202
      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }
207
    return _possibleConstructorReturn(this, result);
  };
}
211
function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
215
function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
219
function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}
223
function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
232
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;
235
  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
237
  return arr2;
}
240
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
244
function toString(val) {
  return val == null ? '' : _typeof(val) === 'object' ? JSON.stringify(val, null, 2) : String(val);
}
248
function $set(target, field, value) {
  Vue.set(target, field, value);
}
function $del(target, field) {
  Vue["delete"](target, field);
}
255
var is = {
  type: function type(arg, _type) {
    return Object.prototype.toString.call(arg) === '[object ' + _type + ']';
  },
  Undef: function Undef(v) {
    return v === undefined || v === null;
  },
  Element: function Element(arg) {
    return _typeof(arg) === 'object' && arg !== null && arg.nodeType === 1 && !is.Object(arg);
  },
  trueArray: function trueArray(data) {
    return Array.isArray(data) && data.length > 0;
  }
};
['Date', 'Object', 'Function', 'String', 'Boolean', 'Array', 'Number'].forEach(function (t) {
  is[t] = function (arg) {
    return is.type(arg, t);
  };
});
function hasProperty(rule, k) {
  return {}.hasOwnProperty.call(rule, k);
}
278
function deepExtend(origin) {
  var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var mode = arguments.length > 2 ? arguments[2] : undefined;
  var isArr = false;
283
  for (var key in target) {
    if (Object.prototype.hasOwnProperty.call(target, key)) {
      var clone = target[key];
287
      if ((isArr = Array.isArray(clone)) || is.Object(clone)) {
        var nst = origin[key] === undefined;
290
        if (isArr) {
          isArr = false;
          nst && $set(origin, key, []);
        } else if (clone._clone && mode !== undefined) {
          if (mode) {
            clone = clone.getRule();
            nst && $set(origin, key, {});
          } else {
            $set(origin, key, clone._clone());
            continue;
          }
        } else {
          nst && $set(origin, key, {});
        }
305
        origin[key] = deepExtend(origin[key], clone, mode);
      } else if (is.Undef(clone)) {
        $set(origin, key, clone);
      } else if (clone.__json !== undefined) {
        $set(origin, key, clone.__json);
      } else if (clone.__origin !== undefined) {
        $set(origin, key, clone.__origin);
      } else {
        $set(origin, key, clone);
      }
    }
  }
318
  return mode !== undefined && Array.isArray(origin) ? origin.filter(function (v) {
    return !v || !v.__ctrl;
  }) : origin;
}
function deepCopy(value) {
  return deepExtend({}, {
    value: value
  }).value;
}
328
function toArray(value) {
  return Array.isArray(value) ? value : [null, undefined, ''].indexOf(value) > -1 ? [] : [value];
}
332
function getSlot(slots, exclude) {
  return Object.keys(slots).reduce(function (lst, name) {
    if (!exclude || exclude.indexOf(name) === -1) {
      lst.push(slots[name]);
    }
338
    return lst;
  }, []);
}
342
var parseFile = function parseFile(file, uid) {
  return {
    url: file,
    name: getFileName(file),
    status: 'done',
    uid: uid + 1
  };
},
    getFileName = function getFileName(file) {
  return toString(file).split('/').pop();
},
    parseUpload = function parseUpload(file) {
  return {
    url: file.url,
    file: file
  };
};
360
var NAME = 'fcUpload';
var Upload = {
  name: NAME,
  formCreateParser: {
    toFormValue: function toFormValue(value) {
      return toArray(value);
    },
    toValue: function toValue(formValue, ctx) {
      return ctx.prop.props.limit === 1 ? formValue[0] || '' : formValue;
    }
  },
  props: {
    limit: {
      type: Number,
      "default": 0
    },
    formCreateInject: {
      type: Object,
      required: true
    },
    value: {
      type: Array,
      "default": function _default() {
        return [];
      }
    },
    onSuccess: {
      type: Function,
      required: true
    },
    onHandle: {
      type: Function,
      "default": function _default(file) {
        this.previewImage = file.url;
        this.previewVisible = true;
      }
    },
    modalTitle: String,
    previewMask: undefined
  },
  data: function data() {
    var fileList = this.value.map(parseFile);
    return {
      defaultUploadList: fileList,
      previewImage: '',
      previewVisible: false,
      uploadList: fileList.map(parseUpload)
    };
  },
  watch: {
    value: function value(n) {
      var fileList = n.map(parseFile);
      this.$refs.upload.sFileList = fileList;
      this.uploadList = fileList.map(parseUpload);
    }
  },
  methods: {
    handleChange: function handleChange(_ref) {
      var file = _ref.file,
          fileList = _ref.fileList;
      var list = this.uploadList;
422
      if (file.status === 'done') {
        this.onSuccess(file, fileList);
        if (file.url) list.push({
          url: file.url,
          file: fileList[fileList.length - 1]
        });
        this.input();
      } else if (file.status === 'removed') {
        list.forEach(function (v, i) {
          if (v.file === file) {
            list.splice(i, 1);
          }
        });
        this.input();
      }
    },
    input: function input() {
      this.$emit('input', this.uploadList.map(function (v) {
        return v.url;
      }));
    }
  },
  render: function render() {
    var _this = this;
447
    var h = arguments[0];
    var isShow = !this.limit || this.limit > this.uploadList.length;
450
    var ctx = _objectSpread2({}, this.formCreateInject.prop);
452
    ctx.on = deepExtend({}, ctx.on || {});
    return h("div", [h("AUpload", helper([{}, ctx, {
      "on": {
        "preview": this.onHandle.bind(this),
        "change": this.handleChange
      },
      "ref": "upload",
      "attrs": {
        "defaultFileList": this.defaultUploadList
      }
    }]), [isShow ? h("template", {
      "slot": "default"
    }, [this.$slots["default"] || h("AIcon", {
      "attrs": {
        "type": "plus"
      }
    })]) : null, getSlot(this.$slots, ['default'])]), h("aModal", {
      "attrs": {
        "mask": this.previewMask,
        "title": this.modalTitle,
        "footer": null
      },
      "model": {
        value: _this.previewVisible,
        callback: function callback($$v) {
          _this.previewVisible = $$v;
        }
      }
    }, [h("img", {
      "style": "width: 100%",
      "attrs": {
        "src": this.previewImage
      }
    })])]);
  }
};
489
function styleInject(css, ref) {
  if (ref === void 0) ref = {};
  var insertAt = ref.insertAt;
493
  if (!css || typeof document === 'undefined') {
    return;
  }
497
  var head = document.head || document.getElementsByTagName('head')[0];
  var style = document.createElement('style');
  style.type = 'text/css';
501
  if (insertAt === 'top') {
    if (head.firstChild) {
      head.insertBefore(style, head.firstChild);
    } else {
      head.appendChild(style);
    }
  } else {
    head.appendChild(style);
  }
511
  if (style.styleSheet) {
    style.styleSheet.cssText = css;
  } else {
    style.appendChild(document.createTextNode(css));
  }
}
518
var css_248z = "._fc-frame .fc-files img {\n    width: 100%;\n    height: 100%;\n    display: inline-block;\n    vertical-align: top;\n}\n\n._fc-frame .fc-upload-cover {\n    opacity: 0;\n    position: absolute;\n    top: 0;\n    bottom: 0;\n    left: 0;\n    right: 0;\n    background: rgba(0, 0, 0, .6);\n    transition: opacity .3s;\n}\n\n._fc-frame .fc-upload-cover i {\n    color: #fff;\n    font-size: 20px;\n    cursor: pointer;\n    margin: 0 2px;\n}\n\n._fc-frame .fc-files:hover .fc-upload-cover {\n    opacity: 1;\n}\n\n._fc-frame .ant-upload {\n    display: block;\n}\n\n._fc-frame .fc-upload-btn, .fc-files {\n    display: inline-block;\n    width: 104px;\n    height: 104px;\n    text-align: center;\n    line-height: 104px;\n    border: 1px solid #c0ccda;\n    border-radius: 4px;\n    overflow: hidden;\n    background: #fff;\n    position: relative;\n    box-shadow: 2px 2px 5px rgba(0, 0, 0, .1);\n    margin-right: 4px;\n    box-sizing: border-box;\n}\n";
styleInject(css_248z);
521
var NAME$1 = 'fcFrame';
var Frame = {
  name: NAME$1,
  props: {
    formCreateInject: {
      type: Object,
      required: true
    },
    type: {
      type: String,
      "default": 'input'
    },
    field: String,
    helper: {
      type: Boolean,
      "default": true
    },
    disabled: {
      type: Boolean,
      "default": false
    },
    src: {
      type: String,
      required: true
    },
    icon: {
      type: String,
      "default": 'folder'
    },
    width: {
      type: [Number, String],
      "default": 500
    },
    height: {
      type: [Number, String],
      "default": 370
    },
    maxLength: {
      type: Number,
      "default": 0
    },
    okBtnText: {
      type: String,
      "default": '确定'
    },
    closeBtnText: {
      type: String,
      "default": '关闭'
    },
    modalTitle: String,
    handleIcon: {
      type: [String, Boolean],
      "default": undefined
    },
    title: String,
    allowRemove: {
      type: Boolean,
      "default": true
    },
    onOpen: {
      type: Function,
      "default": function _default() {}
    },
    onOk: {
      type: Function,
      "default": function _default() {}
    },
    onCancel: {
      type: Function,
      "default": function _default() {}
    },
    onLoad: {
      type: Function,
      "default": function _default() {}
    },
    onBeforeRemove: {
      type: Function,
      "default": function _default() {}
    },
    onRemove: {
      type: Function,
      "default": function _default() {}
    },
    onHandle: {
      type: Function,
      "default": function _default(src) {
        this.previewImage = this.getSrc(src);
        this.previewVisible = true;
      }
    },
    modal: {
      type: Object,
      "default": function _default() {
        return {};
      }
    },
    srcKey: {
      type: [String, Number]
    },
    value: [Array, String, Number, Object],
    previewMask: undefined,
    footer: {
      type: Boolean,
      "default": true
    },
    reload: {
      type: Boolean,
      "default": true
    },
    closeBtn: {
      type: Boolean,
      "default": true
    },
    okBtn: {
      type: Boolean,
      "default": true
    }
  },
  data: function data() {
    return {
      fileList: toArray(this.value),
      previewVisible: false,
      frameVisible: false,
      previewImage: ''
    };
  },
  watch: {
    value: function value(n) {
      this.fileList = toArray(n);
    },
    fileList: function fileList(n) {
      var val = this.maxLength === 1 ? n[0] || '' : n;
      this.$emit('input', val);
      this.$emit('change', val);
    }
  },
  methods: {
    key: function key(unique) {
      return unique;
    },
    closeModal: function closeModal(close) {
      this.$emit(close ? '$close' : '$ok');
664
      if (this.reload) {
        this.$off('$ok');
        this.$off('$close');
      }
669
      this.frameVisible = false;
    },
    showModal: function showModal() {
      if (this.disabled || false === this.onOpen()) return;
      this.frameVisible = true;
    },
    makeInput: function makeInput() {
      var _this = this;
678
      var h = this.$createElement;
      var props = {
        type: 'text',
        value: this.fileList.map(function (v) {
          return _this.getSrc(v);
        }).toString(),
        readonly: true
      };
      return h("AInput", helper([{}, {
        "props": props
      }, {
        "key": this.key('input')
      }]), [h("AIcon", {
        "attrs": {
          "type": this.icon
        },
        "slot": "addonAfter",
        "on": {
          "click": this.showModal
        }
      }), this.fileList.length ? h("AIcon", {
        "attrs": {
          "type": "close-circle"
        },
        "slot": "suffix",
        "on": {
          "click": function click() {
            return _this.fileList = [];
          }
        }
      }) : null]);
    },
    makeGroup: function makeGroup(children) {
      var h = this.$createElement;
      if (!this.maxLength || this.fileList.length < this.maxLength) children.push(this.makeBtn());
      return h("div", {
        "key": this.key('group')
      }, _toConsumableArray(children));
    },
    makeItem: function makeItem(index, children) {
      var h = this.$createElement;
      return h("div", {
        "class": 'fc-files',
        "key": this.key('file' + index)
      }, _toConsumableArray(children));
    },
    valid: function valid(f) {
      var field = this.formCreateInject.field || this.field;
      if (field && f !== field) throw new Error('[frame]无效的字段值');
    },
    makeIcons: function makeIcons(val, index) {
      var h = this.$createElement;
731
      if (this.handleIcon !== false || this.allowRemove === true) {
        var icons = [];
        if (this.type !== 'file' && this.handleIcon !== false || this.type === 'file' && this.handleIcon) icons.push(this.makeHandleIcon(val, index));
        if (this.allowRemove) icons.push(this.makeRemoveIcon(val, index));
        return h("div", {
          "class": 'fc-upload-cover',
          "key": this.key('uc')
        }, [icons]);
      }
    },
    makeHandleIcon: function makeHandleIcon(val, index) {
      var _this2 = this;
744
      var h = this.$createElement;
      return h("AIcon", {
        "attrs": {
          "type": this.handleIcon === true || this.handleIcon === undefined ? 'eye-o' : this.handleIcon
        },
        "on": {
          "click": function click() {
            return _this2.handleClick(val);
          }
        },
        "key": this.key('hi' + index)
      });
    },
    makeRemoveIcon: function makeRemoveIcon(val, index) {
      var _this3 = this;
760
      var h = this.$createElement;
      return h("AIcon", {
        "attrs": {
          "type": "delete"
        },
        "on": {
          "click": function click() {
            return _this3.handleRemove(val);
          }
        },
        "key": this.key('ri' + index)
      });
    },
    makeFiles: function makeFiles() {
      var _this4 = this;
776
      var h = this.$createElement;
      return this.makeGroup(this.fileList.map(function (src, index) {
        return _this4.makeItem(index, [h("AIcon", {
          "attrs": {
            "type": "file"
          },
          "on": {
            "click": function click() {
              return _this4.handleClick(src);
            }
          }
        }), _this4.makeIcons(src, index)]);
      }));
    },
    makeImages: function makeImages() {
      var _this5 = this;
793
      var h = this.$createElement;
      return this.makeGroup(this.fileList.map(function (src, index) {
        return _this5.makeItem(index, [h("img", {
          "attrs": {
            "src": _this5.getSrc(src)
          }
        }), _this5.makeIcons(src, index)]);
      }));
    },
    makeBtn: function makeBtn() {
      var _this6 = this;
805
      var h = this.$createElement;
      return h("div", {
        "class": 'fc-upload-btn',
        "on": {
          "click": function click() {
            return _this6.showModal();
          }
        },
        "key": this.key('btn')
      }, [h("AIcon", {
        "attrs": {
          "type": this.icon,
          "theme": "filled"
        }
      })]);
    },
    handleClick: function handleClick(src) {
      return this.onHandle(src);
    },
    handleRemove: function handleRemove(src) {
      if (this.disabled) return;
827
      if (false !== this.onBeforeRemove(src)) {
        this.fileList.splice(this.fileList.indexOf(src), 1);
        this.onRemove(src);
      }
    },
    getSrc: function getSrc(src) {
      return !this.srcKey ? src : src[this.srcKey];
    },
    frameLoad: function frameLoad(iframe) {
      var _this7 = this;
838
      this.onLoad(iframe);
840
      try {
        if (this.helper === true) {
          iframe['form_create_helper'] = {
            close: function close(field) {
              _this7.valid(field);
846
              _this7.closeModal();
            },
            set: function set(field, value) {
              _this7.valid(field);
851
              if (!_this7.disabled) _this7.$emit('input', value);
            },
            get: function get(field) {
              _this7.valid(field);
856
              return _this7.value;
            },
            onOk: function onOk(fn) {
              return _this7.$on('$ok', fn);
            },
            onClose: function onClose(fn) {
              return _this7.$on('$close', fn);
            }
          };
        }
      } catch (e) {
        console.log(e);
      }
    },
    makeFooter: function makeFooter() {
      var _this8 = this;
873
      var h = this.$createElement;
      var _this$$props = this.$props,
          okBtnText = _this$$props.okBtnText,
          closeBtnText = _this$$props.closeBtnText,
          closeBtn = _this$$props.closeBtn,
          okBtn = _this$$props.okBtn,
          footer = _this$$props.footer;
      var node = [];
      if (!footer) return node;
      if (closeBtn) node.push(h("AButton", {
        "on": {
          "click": function click() {
            return _this8.onCancel() !== false && _this8.closeModal(true);
          }
        }
      }, [closeBtnText]));
      if (okBtn) node.push(h("AButton", {
        "attrs": {
          "type": "primary"
        },
        "on": {
          "click": function click() {
            return _this8.onOk() !== false && _this8.closeModal();
          }
        }
      }, [okBtnText]));
      return node;
    }
  },
  render: function render() {
    var _this9 = this;
905
    var h = arguments[0];
    var type = this.type;
    var Node;
    if (type === 'input') Node = this.makeInput();else if (type === 'image') Node = this.makeImages();else Node = this.makeFiles();
    var _this$$props2 = this.$props,
        _this$$props2$width = _this$$props2.width,
        width = _this$$props2$width === void 0 ? '30%' : _this$$props2$width,
        height = _this$$props2.height,
        src = _this$$props2.src,
        title = _this$$props2.title,
        modalTitle = _this$$props2.modalTitle;
    this.$nextTick(function () {
      if (_this9.$refs.frame) {
        _this9.frameLoad(_this9.$refs.frame.contentWindow || {});
      }
    });
    return h("div", {
      "class": "_fc-frame"
    }, [Node, h("aModal", {
      "attrs": {
        "mask": this.previewMask,
        "title": modalTitle,
        "footer": null
      },
      "model": {
        value: _this9.previewVisible,
        callback: function callback($$v) {
          _this9.previewVisible = $$v;
        }
      }
    }, [h("img", {
      "attrs": {
        "alt": "example",
        "src": this.previewImage
      },
      "style": "width: 100%"
    })]), h("aModal", helper([{}, {
      "props": _objectSpread2({
        width: width,
        title: title
      }, this.modal)
    }, {
      "attrs": {
        "visible": this.frameVisible
      },
      "on": {
        "cancel": function cancel() {
          return _this9.closeModal(true);
        }
      }
    }]), [this.frameVisible || !this.reload ? h("iframe", {
      "ref": "frame",
      "attrs": {
        "src": src,
        "frameborder": "0"
      },
      "style": {
        'height': height,
        'border': '0 none',
        'width': '100%'
      }
    }) : null, h("div", {
      "slot": "footer"
    }, [this.makeFooter()])])]);
  },
  mounted: function mounted() {
    this.$on('fc.closeModal', this.closeModal);
  }
};
975
var NAME$2 = 'fcGroup';
var Group = {
  name: NAME$2,
  props: {
    field: String,
    rule: [Array, Object],
    rules: Array,
    expand: Number,
    options: Object,
    formCreateInject: {
      type: Object,
      required: true
    },
    button: {
      type: Boolean,
      "default": true
    },
    max: {
      type: Number,
      "default": 0
    },
    min: {
      type: Number,
      "default": 0
    },
    value: {
      type: Array,
      "default": function _default() {
        return [];
      }
    },
    disabled: {
      type: Boolean,
      "default": false
    },
    syncDisabled: {
      type: Boolean,
      "default": true
    },
    fontSize: {
      type: Number,
      "default": 28
    },
    onBeforeRemove: {
      type: Function,
      "default": function _default() {}
    },
    onBeforeAdd: {
      type: Function,
      "default": function _default() {}
    }
  },
  data: function data() {
    return {
      len: 0,
      cacheRule: {},
      cacheValue: {}
    };
  },
  computed: {
    formRule: function formRule() {
      if (this.rule) {
        return Array.isArray(this.rule) ? this.rule : [this.rule];
      }
1040
      if (this.rules) {
        return this.rules;
      }
1044
      return [];
    }
  },
  watch: {
    disabled: function disabled(n) {
      if (this.syncDisabled) {
        var lst = this.cacheRule;
        Object.keys(lst).forEach(function (k) {
          lst[k].$f.disabled(n);
        });
      }
    },
    expand: function expand(n) {
      var d = n - this.value.length;
1059
      if (d > 0) {
        this.expandRule(d);
      }
    },
    value: function value(n) {
      var _this = this;
1066
      n = n || [];
      var keys = Object.keys(this.cacheRule),
          total = keys.length,
          len = total - n.length;
1071
      if (len < 0) {
        for (var i = len; i < 0; i++) {
          this.addRule(n.length + i);
        }
1076
        for (var _i = 0; _i < total; _i++) {
          this.setValue(keys[_i], n[_i]);
        }
      } else {
        if (len > 0) {
          for (var _i2 = 0; _i2 < len; _i2++) {
            this.removeRule(keys[total - _i2 - 1]);
          }
1085
          this.subForm();
        }
1088
        n.forEach(function (val, i) {
          _this.setValue(keys[i], n[i]);
        });
      }
    }
  },
  methods: {
    _value: function _value(v) {
      return v && hasProperty(v, this.field) ? v[this.field] : v;
    },
    cache: function cache(k, val) {
      this.cacheValue[k] = JSON.stringify(val);
    },
    input: function input(value) {
      this.$emit('input', value);
      this.$emit('change', value);
    },
    formData: function formData(key, _formData) {
      var _this2 = this;
1108
      var cacheRule = this.cacheRule;
      var keys = Object.keys(cacheRule);
1111
      if (keys.filter(function (k) {
        return cacheRule[k].$f;
      }).length !== keys.length) {
        return;
      }
1117
      var value = keys.map(function (k) {
        var data = key === k ? _formData : _objectSpread2({}, _this2.cacheRule[k].$f.form);
        var value = _this2.field ? data[_this2.field] || null : data;
1121
        _this2.cache(k, value);
1123
        return value;
      });
      this.input(value);
    },
    setValue: function setValue(key, value) {
      var field = this.field,
          $f = this.cacheRule[key].$f;
1131
      if (field) {
        value = _defineProperty({}, field, this._value(value));
      }
1135
      if (this.cacheValue[key] === JSON.stringify(field ? value[field] : value)) {
        return;
      }
1139
      this.cache(key, value);
      $f.coverValue(value || {});
    },
    addRule: function addRule(i, emit) {
      var _this3 = this;
1145
      var rule = this.formCreateInject.form.copyRules(this.formRule);
      var options = this.options ? _objectSpread2({}, this.options) : {
        submitBtn: false,
        resetBtn: false
      };
      options.formData = this.field ? _defineProperty({}, this.field, this._value(this.value[i])) : this.value[i] || {};
      this.$set(this.cacheRule, ++this.len, {
        rule: rule,
        options: options
      });
1156
      if (emit) {
        this.$nextTick(function () {
          return _this3.$emit('add', rule, Object.keys(_this3.cacheRule).length - 1);
        });
      }
    },
    add$f: function add$f(i, key, $f) {
      var _this4 = this;
1165
      this.cacheRule[key].$f = $f;
      this.subForm();
      this.$nextTick(function () {
        if (_this4.syncDisabled) {
          $f.disabled(_this4.disabled);
        }
1172
        _this4.$emit('itemMounted', $f, Object.keys(_this4.cacheRule).indexOf(key));
      });
    },
    subForm: function subForm() {
      var _this5 = this;
1178
      this.formCreateInject.subForm(Object.keys(this.cacheRule).map(function (k) {
        return _this5.cacheRule[k].$f;
      }));
    },
    removeRule: function removeRule(key, emit) {
      var _this6 = this;
1185
      var index = Object.keys(this.cacheRule).indexOf(key);
      this.$delete(this.cacheRule, key);
      this.$delete(this.cacheValue, key);
1189
      if (emit) {
        this.$nextTick(function () {
          return _this6.$emit('remove', index);
        });
      }
    },
    add: function add(i) {
      if (this.disabled || false === this.onBeforeAdd(this.value)) {
        return;
      }
1200
      this.addRule(i, true);
    },
    del: function del(index, key) {
      if (this.disabled || false === this.onBeforeRemove(this.value)) {
        return;
      }
1207
      this.removeRule(key, true);
      this.subForm();
      this.value.splice(index, 1);
      this.input(this.value);
    },
    addIcon: function addIcon(key) {
      var h = this.$createElement;
      return h("AIcon", {
        "key": "a".concat(key),
        "attrs": {
          "type": "plus-circle"
        },
        "style": "font-size:".concat(this.fontSize, "px;cursor:").concat(this.disabled ? 'not-allowed;color:#c9cdd4' : 'pointer', ";"),
        "on": {
          "click": this.add
        }
      });
    },
    delIcon: function delIcon(index, key) {
      var _this7 = this;
1228
      var h = this.$createElement;
      return h("AIcon", {
        "key": "d".concat(key),
        "attrs": {
          "type": "minus-circle"
        },
        "style": "font-size:".concat(this.fontSize, "px;cursor:").concat(this.disabled ? 'not-allowed;color:#c9cdd4' : 'pointer;color:#606266', ";"),
        "on": {
          "click": function click() {
            return _this7.del(index, key);
          }
        }
      });
    },
    makeIcon: function makeIcon(total, index, key) {
      var _this8 = this;
1245
      if (this.$scopedSlots.button) {
        return this.$scopedSlots.button({
          total: total,
          index: index,
          vm: this,
          key: key,
          del: function del() {
            return _this8.del(index, key);
          },
          add: this.add
        });
      }
1258
      if (index === 0) {
        return [this.max !== 0 && total >= this.max ? null : this.addIcon(key), this.min === 0 || total > this.min ? this.delIcon(index, key) : null];
      }
1262
      if (index >= this.min) {
        return this.delIcon(index, key);
      }
    },
    emitEvent: function emitEvent(name, args, index, key) {
      this.$emit.apply(this, [name].concat(_toConsumableArray(args), [this.cacheRule[key].$f, index]));
    },
    expandRule: function expandRule(n) {
      for (var i = 0; i < n; i++) {
        this.value.push(this.field ? null : {});
      }
    }
  },
  created: function created() {
    var d = (this.expand || 0) - this.value.length;
1278
    if (d > 0) {
      this.expandRule(d);
    }
1282
    for (var i = 0; i < this.value.length; i++) {
      this.addRule(i);
    }
  },
  render: function render() {
    var _this9 = this;
1289
    var h = arguments[0];
    var keys = Object.keys(this.cacheRule);
    var button = this.button;
    return keys.length === 0 ? this.$scopedSlots["default"] ? this.$scopedSlots["default"]({
      vm: this,
      add: this.add
    }) : h("AIcon", {
      "key": 'a_def',
      "attrs": {
        "type": "plus-circle"
      },
      "style": "font-size:".concat(this.fontSize, "px;vertical-align:middle;color:").concat(this.disabled ? '#c9cdd4;cursor: not-allowed' : '#606266;cursor:pointer', ";"),
      "on": {
        "click": this.add
      }
    }) : h("div", {
      "key": 'con'
    }, [keys.map(function (key, index) {
      var _this9$cacheRule$key = _this9.cacheRule[key],
          rule = _this9$cacheRule$key.rule,
          options = _this9$cacheRule$key.options;
      return h("ARow", {
        "attrs": {
          "align": "middle",
          "type": "flex"
        },
        "key": key,
        "style": "border-bottom:1px dashed #d9d9d9;margin-bottom:10px;"
      }, [h("ACol", {
        "attrs": {
          "span": button ? 20 : 24
        }
      }, [h("FormCreate", helper([{
        "key": key
      }, {
        "on": {
          'update:value': function updateValue(formData) {
            return _this9.formData(key, formData);
          },
          'emit-event': function emitEvent(name) {
            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
              args[_key - 1] = arguments[_key];
            }
1333
            return _this9.emitEvent(name, args, index, key);
          },
          input: function input($f) {
            return _this9.add$f(index, key, $f);
          }
        }
      }, {
        "attrs": {
          "rule": rule,
          "option": options,
          "extendOption": true
        }
      }]))]), button ? h("ACol", {
        "attrs": {
          "span": 2,
          "pull": 1,
          "push": 1
        }
      }, [_this9.makeIcon(keys.length, index, key)]) : null]);
    })]);
  },
  beforeMount: function beforeMount() {
    this.$options.components.FormCreate = this.formCreateInject.form.$form();
  }
};
1359
var NAME$3 = 'fcSubForm';
var Sub = {
  name: NAME$3,
  props: {
    rule: Array,
    options: Object,
    formCreateInject: {
      type: Object,
      required: true
    },
    value: {
      type: Object,
      "default": function _default() {
        return {};
      }
    },
    disabled: {
      type: Boolean,
      "default": false
    },
    syncDisabled: {
      type: Boolean,
      "default": true
    }
  },
  data: function data() {
    return {
      cacheRule: {},
      cacheValue: {}
    };
  },
  watch: {
    disabled: function disabled(n) {
      this.syncDisabled && this.cacheRule.$f.disabled(n);
    },
    value: function value(n) {
      this.setValue(n);
    }
  },
  methods: {
    formData: function formData(value) {
      this.cacheValue = JSON.stringify(value);
      this.$emit('input', value);
      this.$emit('change', value);
    },
    setValue: function setValue(value) {
      var str = JSON.stringify(value);
1407
      if (this.cacheValue === str) {
        return;
      }
1411
      this.cacheValue = str;
      this.cacheRule.$f.coverValue(value || {});
    },
    addRule: function addRule() {
      var options = this.options ? this.options : {
        submitBtn: false,
        resetBtn: false
      };
      options.formData = _objectSpread2({}, this.value || {});
      this.cacheRule = {
        rule: this.rule,
        options: options
      };
    },
    add$f: function add$f($f) {
      var _this = this;
1428
      this.cacheRule.$f = $f;
      this.subForm();
      this.$nextTick(function () {
        _this.syncDisabled && $f.disabled(_this.disabled);
1433
        _this.$emit('itemMounted', $f);
      });
    },
    subForm: function subForm() {
      this.formCreateInject.subForm(this.cacheRule.$f);
    },
    emitEvent: function emitEvent(name) {
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
1444
      this.$emit.apply(this, [name].concat(args));
    }
  },
  created: function created() {
    this.addRule();
  },
  render: function render() {
    var h = arguments[0];
    var _this$cacheRule = this.cacheRule,
        rule = _this$cacheRule.rule,
        options = _this$cacheRule.options;
    return h("FormCreate", helper([{}, {
      "on": {
        'update:value': this.formData,
        'emit-event': this.emitEvent,
        input: this.add$f
      }
    }, {
      "attrs": {
        "rule": rule,
        "option": options,
        "extendOption": true
      }
    }]));
  },
  beforeMount: function beforeMount() {
    this.$options.components.FormCreate = this.formCreateInject.form.$form();
  }
};
1474
var components = [Upload, Frame, Group, Sub];
1476
var checkbox = {
  name: 'checkbox',
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;
    if (!hasProperty(props, 'options')) props.options = ctx.prop.options || [];
  }
};
1484
var radio = _objectSpread2(_objectSpread2({}, checkbox), {}, {
  name: 'radio'
});
1488
var select = _objectSpread2(_objectSpread2({}, checkbox), {}, {
  name: 'select'
});
1492
var _extends$1 = Object.assign || function (a) {
  for (var b, c = 1; c < arguments.length; c++) {
    for (var d in b = arguments[c], b) {
      Object.prototype.hasOwnProperty.call(b, d) && $set(a, d, b[d]);
    }
  }
1499
  return a;
};
1502
function extend() {
  return _extends$1.apply(this, arguments);
}
1506
var NAME$4 = 'FormCreate';
function $FormCreate(FormCreate) {
  return {
    name: NAME$4,
    componentName: NAME$4,
    model: {
      prop: 'api'
    },
    provide: function provide() {
      return {
        $pfc: this
      };
    },
    inject: {
      $pfc: {
        "default": null
      }
    },
    props: {
      rule: {
        type: Array,
        required: true
      },
      option: {
        type: Object,
        "default": function _default() {
          return {};
        }
      },
      extendOption: Boolean,
      value: Object,
      api: Object
    },
    data: function data() {
      return {
        formData: undefined,
        destroyed: false,
        validate: {},
        $f: undefined,
        isShow: true,
        unique: 1,
        renderRule: _toConsumableArray(this.rule || []),
        ctxInject: {},
        updateValue: ''
      };
    },
    render: function render() {
      return this.formCreate.render();
    },
    methods: {
      _refresh: function _refresh() {
        ++this.unique;
      },
      _renderRule: function _renderRule() {
        this.renderRule = _toConsumableArray(this.rule || []);
      },
      _updateValue: function _updateValue(value) {
        if (this.destroyed) return;
        this.updateValue = JSON.stringify(value);
        this.$emit('update:value', value);
      }
    },
    watch: {
      value: {
        handler: function handler(n) {
          if (JSON.stringify(n) === this.updateValue) return;
          this.$f.setValue(n);
        },
        deep: true
      },
      option: {
        handler: function handler(n) {
          this.formCreate.initOptions(n);
          this.$f.refresh();
        },
        deep: true
      },
      rule: function rule(n) {
        var _this = this;
1586
        if (n.length === this.renderRule.length && n.every(function (v) {
          return _this.renderRule.indexOf(v) > -1;
        })) return;
        this.formCreate.$handle.reloadRule(n);
1591
        this._renderRule();
      }
    },
    beforeCreate: function beforeCreate() {
      var _this2 = this;
1597
      var _this$$options$propsD = this.$options.propsData,
          rule = _this$$options$propsD.rule,
          option = _this$$options$propsD.option;
      this.formCreate = new FormCreate(this, rule, option);
      Object.keys(this.formCreate.prop).forEach(function (k) {
        extend(_this2.$options[k], _this2.formCreate.prop[k]);
      });
    }
  };
}
1608
var normalMerge$1 = ['attrs', 'props', 'domProps', 'scopedSlots'];
var toArrayMerge$1 = ['class', 'style', 'directives'];
var functionalMerge$1 = ['on', 'nativeOn'];
1612
var mergeProps = function mergeProps(objects) {
  var initial = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1616
  var _normalMerge = [].concat(normalMerge$1, _toConsumableArray(opt['normal'] || []));
1618
  var _toArrayMerge = [].concat(toArrayMerge$1, _toConsumableArray(opt['array'] || []));
1620
  var _functionalMerge = [].concat(functionalMerge$1, _toConsumableArray(opt['functional'] || []));
1622
  var propsMerge = opt['props'] || [];
  return objects.reduce(function (a, b) {
    for (var key in b) {
      if (a[key]) {
        if (propsMerge.indexOf(key) > -1) {
          a[key] = mergeProps([b[key]], a[key]);
        } else if (_normalMerge.indexOf(key) > -1) {
          a[key] = _objectSpread2(_objectSpread2({}, a[key]), b[key]);
        } else if (_toArrayMerge.indexOf(key) > -1) {
          var arrA = a[key] instanceof Array ? a[key] : [a[key]];
          var arrB = b[key] instanceof Array ? b[key] : [b[key]];
          a[key] = [].concat(_toConsumableArray(arrA), _toConsumableArray(arrB));
        } else if (_functionalMerge.indexOf(key) > -1) {
          for (var event in b[key]) {
            if (a[key][event]) {
              var _arrA = a[key][event] instanceof Array ? a[key][event] : [a[key][event]];
1639
              var _arrB = b[key][event] instanceof Array ? b[key][event] : [b[key][event]];
1641
              a[key][event] = [].concat(_toConsumableArray(_arrA), _toConsumableArray(_arrB));
            } else {
              a[key][event] = b[key][event];
            }
          }
        } else if (key === 'hook') {
          for (var hook in b[key]) {
            if (a[key][hook]) {
              a[key][hook] = mergeFn$1(a[key][hook], b[key][hook]);
            } else {
              a[key][hook] = b[key][hook];
            }
          }
        } else {
          a[key] = b[key];
        }
      } else {
        if (_normalMerge.indexOf(key) > -1 || _functionalMerge.indexOf(key) > -1 || propsMerge.indexOf(key) > -1) {
          a[key] = _objectSpread2({}, b[key]);
        } else if (_toArrayMerge.indexOf(key) > -1) {
          a[key] = b[key] instanceof Array ? _toConsumableArray(b[key]) : _typeof(b[key]) === 'object' ? _objectSpread2({}, b[key]) : b[key];
        } else a[key] = b[key];
      }
    }
1666
    return a;
  }, initial);
};
1670
var mergeFn$1 = function mergeFn(fn1, fn2) {
  return function () {
    fn1 && fn1.apply(this, arguments);
    fn2 && fn2.apply(this, arguments);
  };
};
1677
var keyAttrs = ['type', 'slot', 'emitPrefix', 'value', 'name', 'native', 'hidden', 'display', 'inject', 'options', 'emit', 'nativeEmit', 'link', 'prefix', 'suffix', 'update', 'sync', 'optionsTo', 'key'];
var arrayAttrs = ['validate', 'children', 'control'];
var normalAttrs = ['effect', 'deep'];
function attrs() {
  return [].concat(keyAttrs, _toConsumableArray(normalMerge$1), _toConsumableArray(toArrayMerge$1), _toConsumableArray(functionalMerge$1), arrayAttrs, normalAttrs);
}
1684
function format(type, msg, rule) {
  return "[form-create ".concat(type, "]: ").concat(msg) + (rule ? '\n\nrule: ' + JSON.stringify(rule.getRule ? rule.getRule() : rule) : '');
}
function tip(msg, rule) {
  console.warn(format('tip', msg, rule));
}
function err(msg, rule) {
  console.error(format('err', msg, rule));
}
function logError(e) {
  err(e.toString());
  console.error(e);
}
1698
var PREFIX = '[[FORM-CREATE-PREFIX-';
var SUFFIX = '-FORM-CREATE-SUFFIX]]';
var $T = '$FN:';
var $TX = '$FNX:';
var FUNCTION = 'function';
function toJson(obj, space) {
  return JSON.stringify(deepExtend([], obj, true), function (key, val) {
    if (val && val._isVue === true) return undefined;
1707
    if (_typeof(val) !== FUNCTION) {
      return val;
    }
1711
    if (hasProperty(val, '__json')) {
      return val.__json;
    }
1715
    if (val.__origin) val = val.__origin;
    if (val.__emit) return undefined;
    return PREFIX + val + SUFFIX;
  }, space);
}
1721
function makeFn(fn) {
  return eval('(' + FUNCTION + '(){return ' + fn + ' })()');
}
1725
function parseFn(fn, mode) {
  if (fn && is.String(fn) && fn.length > 4) {
    var v = fn.trim();
    var flag = false;
1730
    try {
      if (v.indexOf(SUFFIX) > 0 && v.indexOf(PREFIX) === 0) {
        v = v.replace(SUFFIX, '').replace(PREFIX, '');
        flag = true;
      } else if (v.indexOf($T) === 0) {
        v = v.replace($T, '');
        flag = true;
      } else if (v.indexOf($TX) === 0) {
        v = makeFn('function($inject){' + v.replace($TX, '') + '}');
        v.__json = fn;
        v.__inject = true;
        return v;
      } else if (!mode && v.indexOf(FUNCTION) === 0 && v !== FUNCTION) {
        flag = true;
      }
1746
      if (!flag) return fn;
      var val = makeFn(v.indexOf(FUNCTION) === -1 && v.indexOf('(') !== 0 ? FUNCTION + ' ' + v : v);
      val.__json = fn;
      return val;
    } catch (e) {
      err("\u89E3\u6790\u5931\u8D25:".concat(v, "\n\nerr: ").concat(e));
      return undefined;
    }
  }
1756
  return fn;
}
function parseJson(json, mode) {
  return JSON.parse(json, function (k, v) {
    if (is.Undef(v) || !v.indexOf) return v;
    return parseFn(v, mode);
  });
}
1765
function enumerable(value, writable) {
  return {
    value: value,
    enumerable: false,
    configurable: false,
    writable: !!writable
  };
} //todo 优化位置
1774
function copyRule(rule, mode) {
  return copyRules([rule], mode || false)[0];
}
function copyRules(rules, mode) {
  return deepExtend([], _toConsumableArray(rules), mode || false);
}
function mergeRule(rule, merge) {
  mergeProps(Array.isArray(merge) ? merge : [merge], rule, {
    array: arrayAttrs,
    normal: normalAttrs
  });
  return rule;
}
function getRule(rule) {
  return is.Function(rule.getRule) ? rule.getRule() : rule;
}
function mergeGlobal(target, merge) {
  if (!target) return merge;
  Object.keys(merge || {}).forEach(function (k) {
    if (merge[k]) {
      target[k] = mergeRule(target[k] || {}, merge[k]);
    }
  });
  return target;
}
function funcProxy(that, proxy) {
  Object.defineProperties(that, Object.keys(proxy).reduce(function (initial, k) {
    initial[k] = {
      get: function get() {
        return proxy[k]();
      }
    };
    return initial;
  }, {}));
}
function byCtx(rule) {
  return rule.__fc__ || (rule.__origin__ ? rule.__origin__.__fc__ : null);
}
function invoke(fn, def) {
  try {
    def = fn();
  } catch (e) {
    logError(e);
  }
1819
  return def;
}
1822
function toLine(name) {
  var line = name.replace(/([A-Z])/g, '-$1').toLocaleLowerCase();
  if (line.indexOf('-') === 0) line = line.substr(1);
  return line;
}
1828
var id = 0;
function uniqueId() {
  return Math.random().toString(36).substr(3, 3) + Number("".concat(Date.now()).concat(++id)).toString(36);
}
1833
function deepSet(data, idx, val) {
  var _data = data,
      to;
  (idx || '').split('.').forEach(function (v) {
    if (to) {
      if (!_data[to] || _typeof(_data[to]) != 'object') {
        _data[to] = {};
      }
1842
      _data = _data[to];
    }
1845
    to = v;
  });
  _data[to] = val;
  return _data;
}
1851
function baseRule() {
  return {
    props: {},
    on: {},
    options: [],
    children: [],
    hidden: false,
    display: true,
    value: undefined
  };
}
function creatorFactory(name, init) {
  return function (title, field, value) {
    var props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
    var maker = new Creator(name, title, field, value, props);
1867
    if (init) {
      if (is.Function(init)) init(maker);else maker.props(init);
    }
1871
    return maker;
  };
}
function Creator(type, title, field, value, props) {
  this._data = extend(baseRule(), {
    type: type,
    title: title,
    field: field,
    value: value,
    props: props || {}
  });
  this.event = this.on;
}
extend(Creator.prototype, {
  getRule: function getRule() {
    return this._data;
  },
  setProp: function setProp(key, value) {
    $set(this._data, key, value);
    return this;
  },
  _clone: function _clone() {
    var clone = new this.constructor();
    clone._data = copyRule(this._data);
    return clone;
  }
});
function appendProto(attrs) {
  attrs.forEach(function (name) {
    Creator.prototype[name] = function (key) {
      mergeRule(this._data, _defineProperty({}, name, arguments.length < 2 ? key : _defineProperty({}, key, arguments[1])));
      return this;
    };
  });
}
appendProto(attrs());
1908
var commonMaker = creatorFactory('');
function create(type, field, title) {
  var make = commonMaker('', field);
  make._data.type = type;
  make._data.title = title;
  return make;
}
function createTmp(template, vm, field, title) {
  var make = commonMaker('', field);
  make._data.type = 'template';
  make._data.template = template;
  make._data.title = title;
  make._data.vm = vm;
  return make;
}
function makerFactory() {
  return {
    create: create,
    createTmp: createTmp,
    template: createTmp,
    factory: creatorFactory
  };
}
1932
function copy(value) {
  return deepCopy(value);
}
1936
function Api(h) {
  function tidyFields(fields) {
    if (is.Undef(fields)) fields = h.fields();else if (!Array.isArray(fields)) fields = [fields];
    return fields;
  }
1942
  function props(fields, key, val) {
    tidyFields(fields).forEach(function (field) {
      h.getCtxs(field).forEach(function (ctx) {
        $set(ctx.rule, key, val);
        h.$render.clearCache(ctx);
      });
    });
  }
1951
  function allSubForm() {
    var subs = h.subForm;
    return Object.keys(subs).reduce(function (initial, k) {
      var sub = subs[k];
      if (!sub) return initial;
      if (Array.isArray(sub)) initial.push.apply(initial, _toConsumableArray(sub));else initial.push(sub);
      return initial;
    }, []);
  }
1961
  var api = {
    helper: {
      tidyFields: tidyFields,
      props: props
    },
1967
    get config() {
      return h.options;
    },
1971
    get options() {
      return h.options;
    },
1975
    get form() {
      return h.form;
    },
1979
    get rule() {
      return h.rules;
    },
1983
    get parent() {
      return h.vm.$pfc && h.vm.$pfc.$f;
    },
1987
    get children() {
      return allSubForm();
    },
1991
    formData: function formData(fields) {
      return tidyFields(fields).reduce(function (initial, id) {
        var ctx = h.getFieldCtx(id);
        if (!ctx) return initial;
        initial[ctx.field] = copy(ctx.rule.value);
        return initial;
      }, copy(h.appendData));
    },
    getValue: function getValue(field) {
      var ctx = h.getFieldCtx(field);
      if (!ctx) return;
      return copy(ctx.rule.value);
    },
    coverValue: function coverValue(formData) {
      h.deferSyncValue(function () {
        api.fields().forEach(function (key) {
          var ctxs = h.fieldCtx[key];
          if (!ctxs) return h.appendData[key] = formData[key];
          var flag = hasProperty(formData, key);
          ctxs.forEach(function (ctx) {
            ctx.rule.value = flag ? formData[key] : undefined;
          });
        });
      });
    },
    setValue: function setValue(field) {
      var formData = field;
      if (arguments.length >= 2) formData = _defineProperty({}, field, arguments[1]);
      h.deferSyncValue(function () {
        Object.keys(formData).forEach(function (key) {
          var ctxs = h.fieldCtx[key];
          if (!ctxs) return h.appendData[key] = formData[key];
          ctxs.forEach(function (ctx) {
            ctx.rule.value = formData[key];
          });
        });
      });
    },
    removeField: function removeField(field) {
      var ctx = h.getCtx(field);
      h.deferSyncValue(function () {
        h.getCtxs(field).forEach(function (ctx) {
          ctx.rm();
        });
      }, true);
      return ctx ? ctx.origin : undefined;
    },
    removeRule: function removeRule(rule) {
      var ctx = rule && byCtx(rule);
      if (!ctx) return;
      ctx.rm();
      return ctx.origin;
    },
    destroy: function destroy() {
      h.vm.$el.parentNode && h.vm.$el.parentNode.removeChild(h.vm.$el);
      h.vm.$destroy();
    },
    fields: function fields() {
      return h.fields();
    },
    append: function append(rule, after, child) {
      var index = h.sort.length - 1,
          rules;
      var ctx = h.getCtx(after);
2056
      if (ctx) {
        if (child) {
          rules = ctx.rule.children;
          index = ctx.rule.children.length - 1;
        } else {
          index = ctx.root.indexOf(ctx.origin);
          rules = ctx.root;
        }
      } else rules = h.rules;
2066
      rules.splice(index + 1, 0, rule);
    },
    prepend: function prepend(rule, after, child) {
      var index = 0,
          rules;
      var ctx = h.getCtx(after);
2073
      if (ctx) {
        if (child) {
          rules = ctx.rule.children;
        } else {
          index = ctx.root.indexOf(ctx.origin);
          rules = ctx.root;
        }
      } else rules = h.rules;
2082
      rules.splice(index, 0, rule);
    },
    hidden: function hidden(state, fields) {
      props(fields, 'hidden', !!state);
      h.refresh();
    },
    hiddenStatus: function hiddenStatus(id) {
      var ctx = h.getCtx(id);
      if (!ctx) return;
      return !!ctx.rule.hidden;
    },
    display: function display(state, fields) {
      props(fields, 'display', !!state);
      h.refresh();
    },
    displayStatus: function displayStatus(id) {
      var ctx = h.getCtx(id);
      if (!ctx) return;
      return !!ctx.rule.display;
    },
    disabled: function disabled(_disabled, fields) {
      tidyFields(fields).forEach(function (field) {
        h.getCtxs(field).forEach(function (ctx) {
          $set(ctx.rule.props, 'disabled', !!_disabled);
        });
      });
      h.refresh();
    },
    model: function model(origin) {
      return h.fields().reduce(function (initial, key) {
        var ctx = h.fieldCtx[key][0];
        initial[key] = origin ? ctx.origin : ctx.rule;
        return initial;
      }, {});
    },
    component: function component(origin) {
      return Object.keys(h.nameCtx).reduce(function (initial, key) {
        var ctx = h.nameCtx[key].map(function (ctx) {
          return origin ? ctx.origin : ctx.rule;
        });
        initial[key] = ctx.length === 1 ? ctx[0] : ctx;
        return initial;
      }, {});
    },
    bind: function bind() {
      return api.form;
    },
    reload: function reload(rules) {
      h.reloadRule(rules);
    },
    updateOptions: function updateOptions(options) {
      h.fc.updateOptions(options);
      api.refresh();
    },
    onSubmit: function onSubmit(fn) {
      api.updateOptions({
        onSubmit: fn
      });
    },
    sync: function sync(field) {
      if (Array.isArray(field)) {
        field.forEach(function (v) {
          return api.sync(v);
        });
        return;
      }
2149
      var ctxs = is.Object(field) ? byCtx(field) : h.getCtxs(field);
2151
      if (!ctxs) {
        return;
      }
2155
      ctxs = Array.isArray(ctxs) ? ctxs : [ctxs];
      ctxs.forEach(function (ctx) {
        if (!ctx.deleted) {
          var subForm = h.subForm[ctx.id];
2160
          if (subForm) {
            if (Array.isArray(subForm)) {
              subForm.forEach(function (form) {
                form.refresh();
              });
            } else if (subForm) {
              subForm.refresh();
            }
          } //ctx.updateKey(true);
2170
2171
          h.$render.clearCache(ctx);
        }
      });
      h.refresh();
    },
    refresh: function refresh() {
      allSubForm().forEach(function (sub) {
        sub.refresh();
      });
      h.$render.clearCacheAll();
      h.refresh();
    },
    refreshOptions: function refreshOptions() {
      h.$manager.updateOptions(h.options);
      api.refresh();
    },
    hideForm: function hideForm(hide) {
      $set(h.vm, 'isShow', !hide);
    },
    changeStatus: function changeStatus() {
      return h.changeStatus;
    },
    clearChangeStatus: function clearChangeStatus() {
      h.changeStatus = false;
    },
    updateRule: function updateRule(id, rule) {
      h.getCtxs(id).forEach(function (ctx) {
        extend(ctx.rule, rule);
      });
    },
    updateRules: function updateRules(rules) {
      Object.keys(rules).forEach(function (id) {
        api.updateRule(id, rules[id]);
      });
    },
    mergeRule: function mergeRule$1(id, rule) {
      h.getCtxs(id).forEach(function (ctx) {
        mergeRule(ctx.rule, rule);
      });
    },
    mergeRules: function mergeRules(rules) {
      Object.keys(rules).forEach(function (id) {
        api.mergeRule(id, rules[id]);
      });
    },
    getRule: function getRule(id, origin) {
      var ctx = h.getCtx(id);
2219
      if (ctx) {
        return origin ? ctx.origin : ctx.rule;
      }
    },
    updateValidate: function updateValidate(id, validate, merge) {
      if (merge) {
        api.mergeRule(id, {
          validate: validate
        });
      } else {
        props(id, 'validate', validate);
      }
    },
    updateValidates: function updateValidates(validates, merge) {
      Object.keys(validates).forEach(function (id) {
        api.updateValidate(id, validates[id], merge);
      });
    },
    refreshValidate: function refreshValidate() {
      h.vm.validate = {};
      api.refresh();
    },
    resetFields: function resetFields(fields) {
      tidyFields(fields).forEach(function (field) {
        h.getCtxs(field).forEach(function (ctx) {
          h.$render.clearCache(ctx);
          ctx.rule.value = copy(ctx.defaultValue);
          h.refreshControl(ctx);
        });
      });
    },
    method: function method(id, name) {
      var el = api.el(id);
      if (!el || !el[name]) throw new Error(format('err', "".concat(name, "\u65B9\u6CD5\u4E0D\u5B58\u5728")));
      return function () {
        return el[name].apply(el, arguments);
      };
    },
    exec: function exec(id, name) {
      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        args[_key - 2] = arguments[_key];
      }
2262
      return invoke(function () {
        return api.method(id, name).apply(void 0, args);
      });
    },
    toJson: function toJson$1(space) {
      return toJson(api.rule, space);
    },
    trigger: function trigger(id, event) {
      var el = api.el(id);
2272
      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }
2276
      el && el.$emit.apply(el, [event].concat(args));
    },
    el: function el(id) {
      var ctx = h.getCtx(id);
      if (ctx) return ctx.el || h.vm.$refs[ctx.ref];
    },
    closeModal: function closeModal(id) {
      var el = api.el(id);
      el && el.$emit && el.$emit('close-modal');
    },
    getSubForm: function getSubForm(field) {
      var ctx = h.getCtx(field);
      return ctx ? h.subForm[ctx.id] : undefined;
    },
    nextTick: function nextTick(fn) {
      h.bus.$once('next-tick', fn);
      h.refresh();
    },
    nextRefresh: function nextRefresh(fn) {
      h.nextRefresh();
      fn && invoke(fn);
    }
  };
  ['on', 'once', 'off', 'set'].forEach(function (n) {
    api[n] = function () {
      var _h$vm;
2303
      (_h$vm = h.vm)["$".concat(n)].apply(_h$vm, arguments);
    };
  });
  api.changeValue = api.changeField = api.setValue;
  return api;
}
2310
function useCache(Render) {
  extend(Render.prototype, {
    initCache: function initCache() {
      this.clearCacheAll();
    },
    clearCache: function clearCache(ctx) {
      if (!this.cache[ctx.id]) {
        ctx.parent && this.clearCache(ctx.parent);
        return;
      }
2321
      if (this.cache[ctx.id].use === true || this.cache[ctx.id].parent) {
        this.$handle.refresh();
      }
2325
      var parent = this.cache[ctx.id].parent;
      this.cache[ctx.id] = null;
      parent && this.clearCache(parent);
    },
    clearCacheAll: function clearCacheAll() {
      this.cache = {};
    },
    setCache: function setCache(ctx, vnode, parent) {
      this.cache[ctx.id] = {
        vnode: vnode,
        use: false,
        parent: parent,
        slot: ctx.rule.slot
      };
    },
    getCache: function getCache(ctx) {
      var cache = this.cache[ctx.id];
      cache.use = true;
      return cache.vnode;
    }
  });
}
2348
function toCase(str) {
  var to = str.replace(/(-[a-z])/g, function (v) {
    return v.replace('-', '').toLocaleUpperCase();
  });
  return lower(to);
}
function lower(str) {
  return str.replace(str[0], str[0].toLowerCase());
}
2358
function useRender(Render) {
  extend(Render.prototype, {
    initRender: function initRender() {
      this.tempList = {};
      this.clearOrgChildren();
    },
    initOrgChildren: function initOrgChildren() {
      var ctxs = this.$handle.ctxs;
      this.orgChildren = Object.keys(ctxs).reduce(function (initial, id) {
        if (ctxs[id].parser.loadChildren !== false) {
          var children = ctxs[id].rule.children;
          initial[id] = is.trueArray(children) ? _toConsumableArray(children) : [];
        }
2372
        return initial;
      }, {});
    },
    clearOrgChildren: function clearOrgChildren() {
      this.orgChildren = {};
    },
    render: function render() {
      var _this = this;
2381
      if (!this.vm.isShow) {
        return;
      }
2385
      this.$h = this.vm.$createElement;
      this.$manager.beforeRender();
      var vn;
2389
      var make = function make() {
        return _this.renderList();
      };
2393
      make.renderSlot = function (slot) {
        return _this.renderList(slot);
      };
2397
      make.renderName = function (name) {
        return _this.renderId(name);
      };
2401
      make.renderField = function (field) {
        return _this.renderId(field, 'field');
      };
2405
      if (this.vm.$scopedSlots.container) {
        vn = [this.vm.$scopedSlots.container(make)];
      } else {
        vn = make();
      }
2411
      return this.$manager.render(vn);
    },
    renderList: function renderList(slot) {
      var _this2 = this;
2416
      return this.sort.map(function (id) {
        return slot ? _this2.renderSlot(_this2.$handle.ctxs[id], slot) : _this2.renderCtx(_this2.$handle.ctxs[id]);
      }).filter(function (val) {
        return val !== undefined;
      });
    },
    makeVm: function makeVm(rule) {
      var _this3 = this;
2425
      var vm = rule.vm;
      if (!vm) return new _vue();else if (is.Function(vm)) return invoke(function () {
        return rule.vm(_this3.$handle.getInjectData(rule));
      });else if (!vm._isVue) return new _vue(vm);
      return vm;
    },
    mergeGlobal: function mergeGlobal(ctx) {
      var g = this.$handle.options.global;
      if (!g) return; //todo 缓存配置,更新 option 更新
2435
      if (!ctx.cacheConfig) ctx.cacheConfig = g[ctx.originType] || g[ctx.type] || g[ctx.trueType] || {};
      ctx.prop = mergeRule({}, [g['*'], ctx.cacheConfig, ctx.prop]);
    },
    setOptions: function setOptions(ctx) {
      if (ctx.prop.optionsTo && ctx.prop.options) {
        deepSet(ctx.prop, ctx.prop.optionsTo, ctx.prop.options);
      }
    },
    deepSet: function deepSet$1(ctx) {
      var deep = ctx.rule.deep;
      deep && Object.keys(deep).sort(function (a, b) {
        return a.length < b.length ? -1 : 1;
      }).forEach(function (str) {
        deepSet(ctx.prop, str, deep[str]);
      });
    },
    setTempProps: function setTempProps(vm, ctx) {
      if (!vm.$props) return;
      var prop = ctx.prop;
      var keys = Object.keys(vm.$props);
      var inject = this.injectProp(ctx);
      var injectKeys = Object.keys(inject);
      keys.forEach(function (key) {
        if (hasProperty(prop.props, key)) vm.$props[key] = prop.props[key];else if (injectKeys.indexOf(key) > -1) vm.$props[key] = inject[key];
      });
      var key = vm.$options.model && vm.$options.model.prop || 'value';
2462
      if (keys.indexOf(key) > -1) {
        vm.$props[key] = prop.value;
      }
    },
    renderTemp: function renderTemp(ctx) {
      var _this4 = this;
2469
      if (!_vue.compile) {
        tip('当前使用的Vue构建版本不支持compile,无法使用template功能');
        return [];
      }
2474
      var rule = ctx.prop;
      var id = ctx.id,
          key = ctx.key;
2478
      if (!this.tempList[id]) {
        if (!ctx.el) {
          ctx.el = this.makeVm(rule);
          this.vm.$nextTick(function () {
            return ctx.parser.mounted(ctx);
          });
        }
2486
        var _vm = ctx.el;
        if (ctx.input) _vm.$on(_vm.$options.model && _vm.$options.model.event || 'input', function (value) {
          _this4.onInput(ctx, value);
        });
        this.tempList[id] = {
          vm: _vm,
          template: _vue.compile(rule.template)
        };
      }
2496
      var _this$tempList$id = this.tempList[id],
          vm = _this$tempList$id.vm,
          template = _this$tempList$id.template;
      this.setTempProps(vm, ctx);
      var vn = template.render.call(vm);
      if (is.Undef(vn.data)) vn.data = {};
      vn.key = key;
      vn.data.ref = ctx.ref;
      vn.data.key = key;
      return vn;
    },
    parseSide: function parseSide(side) {
      return is.Object(side) ? mergeRule({}, side) : side;
    },
    renderSides: function renderSides(vn, ctx, temp) {
      var prop = ctx[temp ? 'rule' : 'prop'];
      return [this.renderRule(this.parseSide(prop.prefix)), vn, this.renderRule(this.parseSide(prop.suffix))];
    },
    renderSlot: function renderSlot(ctx, slot) {
      return ctx.rule.slot === slot ? this.renderCtx(ctx) : undefined;
    },
    renderId: function renderId(name, type) {
      var _this5 = this;
2520
      var ctxs = this.$handle[type === 'field' ? 'fieldCtx' : 'nameCtx'][name];
      return ctxs ? ctxs.map(function (ctx) {
        return _this5.renderCtx(ctx, ctx.parent);
      }) : undefined;
    },
    renderCtx: function renderCtx(ctx, parent) {
      if (ctx.type === 'hidden') return;
      var rule = ctx.rule;
2529
      if (!this.cache[ctx.id] || this.cache[ctx.id].slot !== rule.slot) {
        var vn;
        var cacheFlag = true;
        var _type = ctx.trueType;
        var none = !(is.Undef(rule.display) || !!rule.display);
2535
        if (_type === 'template' && !rule.template) {
          vn = this.renderSides(this.renderChildren(ctx), ctx, true);
2538
          if (none) {
            this.display(vn);
          }
2542
          vn = this.item(ctx, vn);
        } else if (_type === 'fcFragment') {
          vn = this.renderChildren(ctx);
        } else {
          ctx.initProp();
          this.mergeGlobal(ctx);
          this.$manager.tidyRule(ctx);
          this.deepSet(ctx);
          this.setOptions(ctx);
          this.ctxProp(ctx);
          var prop = ctx.prop;
          prop.props.formCreateInject = this.injectProp(ctx);
2555
          if (prop.hidden) {
            this.setCache(ctx, undefined, parent);
            return;
          }
2560
          if (_type === 'template' && prop.template) {
            vn = this.renderTemp(ctx);
            cacheFlag = false;
          } else {
            var children = [];
2566
            if (ctx.parser.renderChildren) {
              children = ctx.parser.renderChildren(ctx);
            } else if (ctx.parser.loadChildren !== false) {
              children = this.renderChildren(ctx);
            }
2572
            var slot = 'type-' + toLine(ctx.type);
2574
            if (this.vm.$scopedSlots[slot]) {
              vn = this.vm.$scopedSlots[slot]({
                rule: rule,
                prop: prop,
                children: children,
                api: this.$handle.api,
                model: prop.model || {}
              });
            } else {
              vn = ctx.parser.render(children, ctx);
            }
          }
2587
          vn = this.renderSides(vn, ctx);
2589
          if (!(!ctx.input && is.Undef(prop["native"])) && prop["native"] !== true) {
            vn = this.$manager.makeWrap(ctx, vn);
          }
2593
          if (none) {
            vn = this.display(vn);
          }
2597
          vn = this.item(ctx, vn);
        }
2600
        if (cacheFlag) {
          this.setCache(ctx, vn, parent);
        }
2604
        return vn;
      }
2607
      return this.getCache(ctx);
    },
    display: function display(vn) {
      var _this6 = this;
2612
      if (Array.isArray(vn)) {
        var data = [];
        vn.forEach(function (v) {
          if (Array.isArray(v)) return _this6.display(v);
          if (_this6.none(v)) data.push(v);
        });
        return data;
      } else {
        return this.none(vn);
      }
    },
    none: function none(vn) {
      if (vn && vn.data) {
        if (Array.isArray(vn.data.style)) {
          vn.data.style.push({
            display: 'none'
          });
        } else {
          vn.data.style = [vn.data.style, {
            display: 'none'
          }];
        }
2635
        return vn;
      }
    },
    item: function item(ctx, vn) {
      return this.$h('fcFragment', {
        slot: ctx.rule.slot,
        key: ctx.key
      }, [vn]);
    },
    injectProp: function injectProp(ctx) {
      var _this7 = this;
2647
      if (!this.vm.ctxInject[ctx.id]) {
        $set(this.vm.ctxInject, ctx.id, {});
      }
2651
      var inject = this.vm.ctxInject[ctx.id];
      extend(inject, {
        api: this.$handle.api,
        form: this.fc.create,
        subForm: function subForm(_subForm) {
          _this7.$handle.addSubForm(ctx, _subForm);
        },
        field: ctx.field,
        options: ctx.prop.options,
        children: ctx.rule.children,
        rule: ctx.rule,
        prop: function () {
          var temp = _objectSpread2({}, ctx.prop);
2665
          temp.on = temp.on ? _objectSpread2({}, temp.on) : {};
          delete temp.model;
          return temp;
        }()
      });
      return inject;
    },
    ctxProp: function ctxProp(ctx, custom) {
      var _this8 = this;
2675
      var ref = ctx.ref,
          key = ctx.key,
          rule = ctx.rule;
      this.$manager.mergeProp(ctx, custom);
      ctx.parser.mergeProp(ctx, custom);
      var props = [{
        ref: ref,
        key: rule.key || "".concat(key, "fc"),
        slot: undefined,
        on: {
          'hook:mounted': function hookMounted() {
            _this8.onMounted(ctx);
          }
        }
      }];
2691
      if (!custom && ctx.input) {
        props.push({
          model: {
            value: this.$handle.getFormData(ctx),
            callback: function callback(value) {
              _this8.onInput(ctx, value);
            },
            expression: "formData.".concat(ctx.id)
          }
        });
      }
2703
      mergeProps(props, ctx.prop);
      return ctx.prop;
    },
    onMounted: function onMounted(ctx) {
      ctx.el = this.vm.$refs[ctx.ref];
2709
      if (ctx.el) {
        (ctx.el.$el || ctx.el).__rule__ = ctx.rule;
      }
2713
      ctx.parser.mounted(ctx);
      this.$handle.effect(ctx, 'mounted');
    },
    onInput: function onInput(ctx, value) {
      this.$handle.onInput(ctx, value);
    },
    renderChildren: function renderChildren(ctx) {
      var _this9 = this;
2722
      var children = ctx.rule.children,
          orgChildren = this.orgChildren[ctx.id];
2725
      var isRm = function isRm(child) {
        return !is.String(child) && child.__fc__ && !_this9.$handle.ctxs[child.__fc__.id];
      };
2729
      if (!is.trueArray(children) && orgChildren) {
        this.$handle.deferSyncValue(function () {
          orgChildren.forEach(function (child) {
            if (!child) return;
2734
            if (isRm(child)) {
              _this9.$handle.rmCtx(child.__fc__);
            }
          });
        });
        this.orgChildren[ctx.id] = [];
        return [];
      }
2743
      orgChildren && this.$handle.deferSyncValue(function () {
        orgChildren.forEach(function (child) {
          if (!child) return;
2747
          if (children.indexOf(child) === -1 && isRm(child)) {
            _this9.$handle.rmCtx(child.__fc__);
          }
        });
      });
      return children.map(function (child) {
        if (!child) return;
        if (is.String(child)) return child;
2756
        if (child.__fc__) {
          return _this9.renderCtx(child.__fc__, ctx);
        }
2760
        if (child.type) {
          _this9.vm.$nextTick(function () {
            _this9.$handle.loadChildren(children, ctx);
2764
            _this9.$handle.refresh();
          });
        }
      });
    },
    defaultRender: function defaultRender(ctx, children) {
      var prop = ctx.prop;
      if (this.vNode[ctx.type]) return this.vNode[ctx.type](prop, children);
      if (this.vNode[ctx.originType]) return this.vNode[ctx.originType](prop, children);
      return this.vNode.make(lower(ctx.originType), prop, children);
    },
    renderRule: function renderRule(rule, children, origin) {
      var _this10 = this;
2778
      if (!rule) return undefined;
      if (is.String(rule)) return rule;
      var type;
2782
      if (origin) {
        type = rule.type;
      } else {
        type = rule.is;
2787
        if (rule.type) {
          type = toCase(rule.type);
          var alias = this.vNode.aliasMap[type];
          if (alias) type = toCase(alias);
        }
      }
2794
      if (!type) return undefined;
      var data = [[children]];
2797
      if (is.trueArray(rule.children)) {
        data.push(rule.children.map(function (v) {
          return _this10.renderRule(v);
        }));
      }
2803
      return this.$h(type, _objectSpread2({}, rule), data);
    }
  });
}
2808
function Render(handle) {
  extend(this, {
    $handle: handle,
    fc: handle.fc,
    vm: handle.vm,
    $manager: handle.$manager,
    vNode: new handle.fc.CreateNode(handle.vm)
  });
  funcProxy(this, {
    options: function options() {
      return handle.options;
    },
    sort: function sort() {
      return handle.sort;
    }
  });
  this.initCache();
  this.initRender();
}
useCache(Render);
useRender(Render);
2830
function useInject(Handler) {
  extend(Handler.prototype, {
    parseInjectEvent: function parseInjectEvent(rule, on) {
      var inject = rule.inject || this.options.injectEvent;
      return this.parseEventLst(rule, on, inject);
    },
    parseEventLst: function parseEventLst(rule, data, inject, deep) {
      var _this = this;
2839
      Object.keys(data).forEach(function (k) {
        var fn = _this.parseEvent(rule, data[k], inject, deep);
2842
        if (fn) {
          data[k] = fn;
        }
      });
      return data;
    },
    parseEvent: function parseEvent(rule, fn, inject, deep) {
      if (is.Function(fn) && (inject !== false && !is.Undef(inject) || fn.__inject)) {
        return this.inject(rule, fn, inject);
      } else if (!deep && Array.isArray(fn) && fn[0] && (is.String(fn[0]) || is.Function(fn[0]))) {
        return this.parseEventLst(rule, fn, inject, true);
      } else if (is.String(fn)) {
        var val = parseFn(fn);
2856
        if (val && fn !== val) {
          return val.__inject ? this.parseEvent(rule, val, inject, true) : val;
        }
      }
    },
    parseEmit: function parseEmit(ctx, on) {
      var _this2 = this;
2864
      var event = {},
          rule = ctx.rule,
          emitPrefix = rule.emitPrefix,
          field = rule.field,
          name = rule.name,
          inject = rule.inject;
      var emit = rule[on ? 'emit' : 'nativeEmit'] || [];
2872
      if (is.trueArray(emit)) {
        var emitKey = emitPrefix || field || name;
2875
        if (emitKey) {
          if (!on) emitKey = "native-".concat(emitKey);
          emit.forEach(function (eventName) {
            if (!eventName) return;
            var eventInject;
2881
            if (is.Object(eventName)) {
              eventInject = eventName.inject;
              eventName = eventName.name;
            }
2886
            var fieldKey = toLine("".concat(emitKey, "-").concat(eventName));
2888
            var fn = function fn() {
              var _this2$vm, _this2$vm2;
2891
              for (var _len = arguments.length, arg = new Array(_len), _key = 0; _key < _len; _key++) {
                arg[_key] = arguments[_key];
              }
2895
              (_this2$vm = _this2.vm).$emit.apply(_this2$vm, [fieldKey].concat(arg));
2897
              (_this2$vm2 = _this2.vm).$emit.apply(_this2$vm2, ['emit-event', fieldKey].concat(arg));
            };
2900
            fn.__emit = true;
2902
            if (!eventInject && inject === false) {
              event[eventName] = fn;
            } else {
              var _inject = eventInject || inject || _this2.options.injectEvent;
2907
              event[eventName] = is.Undef(_inject) ? fn : _this2.inject(rule, fn, _inject);
            }
          });
        }
      }
2913
      ctx.computed[on ? 'on' : 'nativeOn'] = event;
      return event;
    },
    getInjectData: function getInjectData(self, inject) {
      var _this$vm$$options$pro = this.vm.$options.propsData,
          option = _this$vm$$options$pro.option,
          rule = _this$vm$$options$pro.rule;
      return {
        api: this.api,
        $f: this.api,
        rule: rule,
        self: self.__origin__,
        option: option,
        inject: inject
      };
    },
    inject: function inject(self, _fn, _inject2) {
      if (_fn.__origin) {
        if (this.watching && !this.loading) return _fn;
        _fn = _fn.__origin;
      }
2935
      var h = this;
2937
      var fn = function fn() {
        var data = h.getInjectData(self, _inject2);
2940
        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }
2944
        data.args = [].concat(args);
        args.unshift(data);
        return _fn.apply(this, args);
      };
2949
      fn.__origin = _fn;
      fn.__json = _fn.__json;
      return fn;
    }
  });
}
2956
var EVENT = ['hook:updated', 'hook:mounted'];
function usePage(Handler) {
  extend(Handler.prototype, {
    usePage: function usePage() {
      var _this = this;
2962
      var page = this.options.page;
      if (!page) return;
      var first = 25;
      var limit = getLimit(this.rules);
2967
      if (is.Object(page)) {
        if (page.first) first = parseInt(page.first, 10) || first;
        if (page.limit) limit = parseInt(page.limit, 10) || limit;
      }
2972
      extend(this, {
        first: first,
        limit: limit,
        pageEnd: this.rules.length <= first
      });
      this.bus.$on('page-end', function () {
        return _this.vm.$emit('page-end', _this.api);
      });
      this.pageLoad();
    },
    pageLoad: function pageLoad() {
      var _this2 = this;
2985
      var pageFn = function pageFn() {
        if (_this2.pageEnd) {
          _this2.vm.$off(EVENT, pageFn);
2989
          _this2.bus.$emit('page-end');
        } else {
          _this2.first += _this2.limit;
          _this2.pageEnd = _this2.rules.length <= _this2.first;
2994
          _this2.loadRule();
2996
          _this2.refresh();
        }
      };
3000
      this.vm.$on(EVENT, pageFn);
    }
  });
}
3005
function getLimit(rules) {
  return rules.length < 31 ? 31 : Math.ceil(rules.length / 3);
}
3009
function useRender$1(Handler) {
  extend(Handler.prototype, {
    clearNextTick: function clearNextTick() {
      this.nextTick && clearTimeout(this.nextTick);
      this.nextTick = null;
    },
    bindNextTick: function bindNextTick(fn) {
      var _this = this;
3018
      this.clearNextTick();
      this.nextTick = setTimeout(function () {
        fn();
        _this.nextTick = null;
      }, 10);
    },
    render: function render() {
      // console.warn('%c render', 'color:green');
      ++this.loadedId;
      if (this.vm.unique > 0) return this.$render.render();else {
        this.vm.unique = 1;
        return [];
      }
    }
  });
}
3035
function bind(ctx) {
  Object.defineProperties(ctx.origin, {
    __fc__: enumerable(ctx, true)
  });
}
3041
function RuleContext(handle, rule) {
  var id = uniqueId();
  extend(this, {
    id: id,
    ref: id,
    wrapRef: id + 'fi',
    rule: rule,
    origin: rule.__origin__ || rule,
    name: rule.name,
    watch: [],
    linkOn: [],
    root: [],
    ctrlRule: [],
    parent: null,
    cacheConfig: null,
    prop: _objectSpread2({}, rule),
    computed: {},
    payload: {},
    input: !!rule.field,
    el: undefined,
    defaultValue: rule.field ? deepCopy(rule.value) : undefined,
    field: rule.field || undefined
  });
  this.updateType();
  this.updateKey();
  bind(this);
  this.update(handle, true);
}
extend(RuleContext.prototype, {
  effectData: function effectData(name) {
    if (!this.payload[name]) {
      this.payload[name] = {};
    }
3075
    return this.payload[name];
  },
  clearEffectData: function clearEffectData(name) {
    delete this.payload[name];
  },
  updateKey: function updateKey(flag) {
    this.key = uniqueId();
    flag && this.parent && this.parent.updateKey(flag);
  },
  updateType: function updateType() {
    this.originType = this.rule.type;
    this.type = toCase(this.rule.type);
  },
  setParser: function setParser(parser) {
    this.parser = parser;
    parser.init(this);
  },
  initProp: function initProp() {
    var _this = this;
3095
    var rule = _objectSpread2({}, this.rule);
3097
    delete rule.children;
    this.prop = mergeProps([rule].concat(_toConsumableArray(Object.keys(this.payload).map(function (k) {
      return _this.payload[k];
    })), [this.computed]));
  },
  check: function check(handle) {
    return this.vm === handle.vm;
  },
  unwatch: function unwatch() {
    this.watch.forEach(function (un) {
      return un();
    });
    this.watch = [];
  },
  unlink: function unlink() {
    this.linkOn.forEach(function (un) {
      return un();
    });
    this.linkOn = [];
  },
  link: function link() {
    this.unlink();
    this.$handle.appendLink(this);
  },
  watchTo: function watchTo() {
    this.$handle.watchCtx(this);
  },
  "delete": function _delete() {
    var undef = void 0;
    this.unwatch();
    this.unlink();
    this.rmCtrl();
    extend(this, {
      deleted: true,
      prop: _objectSpread2({}, this.rule),
      computed: {},
      el: undef,
      $handle: undef,
      $render: undef,
      $api: undef,
      vm: undef,
      vNode: undef,
      parent: null,
      cacheConfig: null
    });
  },
  rmCtrl: function rmCtrl() {
    this.ctrlRule.forEach(function (ctrl) {
      return ctrl.__fc__ && ctrl.__fc__.rm();
    });
    this.ctrlRule = [];
  },
  rm: function rm() {
    var _this2 = this;
3152
    var _rm = function _rm() {
      var index = _this2.root.indexOf(_this2.origin);
3155
      if (index > -1) {
        _this2.root.splice(index, 1);
3158
        _this2.$handle && _this2.$handle.refresh();
      }
    };
3162
    if (this.deleted) {
      _rm();
3165
      return;
    }
3168
    this.$handle.noWatch(function () {
      _this2.$handle.deferSyncValue(function () {
        _this2.rmCtrl();
3172
        _rm();
3174
        _this2.$handle.rmCtx(_this2);
3176
        extend(_this2, {
          root: []
        });
      }, _this2.input);
    });
  },
  update: function update(handle, init) {
    extend(this, {
      deleted: false,
      $handle: handle,
      $render: handle.$render,
      $api: handle.api,
      vm: handle.vm,
      trueType: handle.getType(this.originType),
      vNode: handle.$render.vNode,
      updated: false
    });
    !init && this.unwatch();
    this.watchTo();
    this.link();
  }
});
3199
function useLoader(Handler) {
  extend(Handler.prototype, {
    nextRefresh: function nextRefresh(fn) {
      var _this = this;
3204
      var id = this.loadedId;
      this.vm.$nextTick(function () {
        id === _this.loadedId && (fn ? fn() : _this.refresh());
      });
    },
    parseRule: function parseRule(_rule) {
      var _this2 = this;
3212
      var rule = getRule(_rule);
      Object.defineProperties(rule, {
        __origin__: enumerable(_rule, true)
      });
      fullRule(rule);
      this.appendValue(rule);
      rule.options = Array.isArray(rule.options) ? rule.options : [];
      [rule, rule['prefix'], rule['suffix']].forEach(function (item) {
        if (!item) {
          return;
        }
3224
        _this2.loadFn(item, rule);
      });
      this.loadCtrl(rule);
3228
      if (rule.update) {
        rule.update = parseFn(rule.update);
      }
3232
      return rule;
    },
    loadFn: function loadFn(item, rule) {
      var _this3 = this;
3237
      ['on', 'props', 'nativeOn', 'deep'].forEach(function (k) {
        item[k] && _this3.parseInjectEvent(rule, item[k]);
      });
    },
    loadCtrl: function loadCtrl(rule) {
      rule.control && rule.control.forEach(function (ctrl) {
        if (ctrl.handle) {
          ctrl.handle = parseFn(ctrl.handle);
        }
      });
    },
    syncProp: function syncProp(ctx) {
      var _this4 = this;
3251
      var rule = ctx.rule;
      is.trueArray(rule.sync) && mergeProps([{
        on: rule.sync.reduce(function (pre, prop) {
          pre["update:".concat(prop)] = function (val) {
            rule.props[prop] = val;
3257
            _this4.vm.$emit('sync', prop, val, rule, _this4.fapi);
          };
3260
          return pre;
        }, {})
      }], ctx.computed);
    },
    loadRule: function loadRule() {
      var _this5 = this;
3267
      // console.warn('%c load', 'color:blue');
      this.cycleLoad = false;
      this.loading = true;
3271
      if (this.pageEnd) {
        this.bus.$emit('load-start');
      }
3275
      this.deferSyncValue(function () {
        _this5._loadRule(_this5.rules);
3278
        _this5.loading = false;
3280
        if (_this5.cycleLoad && _this5.pageEnd) {
          return _this5.loadRule();
        }
3284
        if (_this5.pageEnd) {
          _this5.bus.$emit('load-end');
        }
3288
        _this5.vm._renderRule();
3290
        _this5.$render.initOrgChildren();
3292
        _this5.syncForm();
      });
    },
    loadChildren: function loadChildren(children, parent) {
      this.cycleLoad = false;
      this.loading = true;
      this.bus.$emit('load-start');
3300
      this._loadRule(children, parent);
3302
      this.loading = false;
3304
      if (this.cycleLoad) {
        return this.loadRule();
      } else {
        this.bus.$emit('load-end');
        this.syncForm();
      }
3311
      this.$render.clearCache(parent);
    },
    _loadRule: function _loadRule(rules, parent) {
      var _this6 = this;
3316
      var preIndex = function preIndex(i) {
        var pre = rules[i - 1];
3319
        if (!pre || !pre.__fc__) {
          return i > 0 ? preIndex(i - 1) : -1;
        }
3323
        var index = _this6.sort.indexOf(pre.__fc__.id);
3325
        return index > -1 ? index : preIndex(i - 1);
      };
3328
      var loadChildren = function loadChildren(children, parent) {
        if (is.trueArray(children)) {
          _this6._loadRule(children, parent);
        }
      };
3334
      rules.map(function (_rule, index) {
        if (parent && (is.String(_rule) || is.Undef(_rule))) return;
        if (!_this6.pageEnd && !parent && index >= _this6.first) return;
        if (!is.Object(_rule) || !getRule(_rule).type) return err('未定义生成规则的 type 字段', _rule);
3339
        if (_rule.__fc__ && _rule.__fc__.root === rules && _this6.ctxs[_rule.__fc__.id]) {
          loadChildren(_rule.__fc__.rule.children, _rule.__fc__);
          return _rule.__fc__;
        }
3344
        var rule = getRule(_rule);
3346
        var isRepeat = function isRepeat() {
          return !!(rule.field && _this6.fieldCtx[rule.field] && _this6.fieldCtx[rule.field][0] !== _rule.__fc__);
        };
3350
        _this6.ruleEffect(rule, 'init', {
          repeat: isRepeat()
        });
3354
        if (isRepeat()) {
          _this6.vm.$emit('repeat-field', _rule, _this6.api);
        }
3358
        var ctx;
        var isCopy = false;
        var isInit = !!_rule.__fc__;
3362
        if (isInit) {
          ctx = _rule.__fc__;
          var check = !ctx.check(_this6);
3366
          if (ctx.deleted) {
            if (check) {
              if (isCtrl(ctx)) {
                return;
              }
3372
              ctx.update(_this6);
            }
          } else {
            if (check) {
              if (isCtrl(ctx)) {
                return;
              }
3380
              rules[index] = _rule = _rule._clone ? _rule._clone() : copyRule(_rule);
              ctx = null;
              isCopy = true;
            }
          }
        }
3387
        if (!ctx) {
          ctx = new RuleContext(_this6, _this6.parseRule(_rule));
3390
          _this6.bindParser(ctx);
        } else {
          if (ctx.originType !== ctx.rule.type) {
            ctx.updateType();
3395
            _this6.bindParser(ctx);
          }
3398
          _this6.appendValue(ctx.rule);
        }
3401
        [false, true].forEach(function (b) {
          return _this6.parseEmit(ctx, b);
        });
3405
        _this6.syncProp(ctx);
3407
        ctx.parent = parent || null;
        ctx.root = rules;
3410
        _this6.setCtx(ctx);
3412
        !isCopy && !isInit && _this6.effect(ctx, 'load');
        ctx.parser.loadChildren === false || loadChildren(ctx.rule.children, ctx);
3415
        if (!parent) {
          var _preIndex = preIndex(index);
3418
          if (_preIndex > -1 || !index) {
            _this6.sort.splice(_preIndex + 1, 0, ctx.id);
          } else {
            _this6.sort.push(ctx.id);
          }
        }
3425
        var r = ctx.rule;
3427
        if (!ctx.updated) {
          ctx.updated = true;
3430
          if (is.Function(r.update)) {
            _this6.bus.$once('load-end', function () {
              _this6.refreshUpdate(ctx, r.value);
            });
          }
3436
          _this6.effect(ctx, 'loaded');
        }
3439
        if (ctx.input) Object.defineProperty(r, 'value', _this6.valueHandle(ctx));
        if (_this6.refreshControl(ctx)) _this6.cycleLoad = true;
        return ctx;
      });
    },
    refreshControl: function refreshControl(ctx) {
      return ctx.input && ctx.rule.control && this.useCtrl(ctx);
    },
    useCtrl: function useCtrl(ctx) {
      var _this7 = this;
3450
      var controls = getCtrl(ctx),
          validate = [],
          api = this.api;
      if (!controls.length) return false;
3455
      var _loop = function _loop(i) {
        var control = controls[i],
            handleFn = control.handle || function (val) {
          return val === control.value;
        };
3461
        if (!is.trueArray(control.rule)) return "continue";
3463
        var data = _objectSpread2(_objectSpread2({}, control), {}, {
          valid: invoke(function () {
            return handleFn(ctx.rule.value, api);
          }),
          ctrl: findCtrl(ctx, control.rule),
          isHidden: is.String(control.rule[0])
        });
3471
        if (data.valid && data.ctrl || !data.valid && !data.ctrl && !data.isHidden) return "continue";
        validate.push(data);
      };
3475
      for (var i = 0; i < controls.length; i++) {
        var _ret = _loop(i);
3478
        if (_ret === "continue") continue;
      }
3481
      if (!validate.length) return false;
      var flag = false;
      this.deferSyncValue(function () {
        validate.reverse().forEach(function (_ref) {
          var isHidden = _ref.isHidden,
              valid = _ref.valid,
              rule = _ref.rule,
              prepend = _ref.prepend,
              append = _ref.append,
              child = _ref.child,
              ctrl = _ref.ctrl;
3493
          if (isHidden) {
            valid ? ctx.ctrlRule.push({
              __ctrl: true,
              children: rule,
              valid: valid
            }) : ctx.ctrlRule.splice(ctx.ctrlRule.indexOf(ctrl), 1);
3500
            _this7.vm.$nextTick(function () {
              _this7.api.hidden(!valid, rule);
            });
3504
            return;
          }
3507
          if (valid) {
            flag = true;
            var ruleCon = {
              type: 'fcFragment',
              "native": true,
              __ctrl: true,
              children: rule
            };
            ctx.ctrlRule.push(ruleCon);
3517
            _this7.bus.$once('load-start', function () {
              // this.cycleLoad = true;
              if (prepend) {
                api.prepend(ruleCon, prepend, child);
              } else if (append || child) {
                api.append(ruleCon, append || ctx.id, child);
              } else {
                ctx.root.splice(ctx.root.indexOf(ctx.origin) + 1, 0, ruleCon);
              }
            });
          } else {
            ctx.ctrlRule.splice(ctx.ctrlRule.indexOf(ctrl), 1);
            var ctrlCtx = byCtx(ctrl);
            ctrlCtx && ctrlCtx.rm();
          }
        });
      });
      this.vm.$emit('control', ctx.origin, this.api);
      this.effect(ctx, 'control');
      return flag;
    },
    reloadRule: function reloadRule(rules) {
      return this._reloadRule(rules);
    },
    _reloadRule: function _reloadRule(rules) {
      var _this8 = this;
3544
      // console.warn('%c reload', 'color:red');
      if (!rules) rules = this.rules;
3547
      var ctxs = _objectSpread2({}, this.ctxs);
3549
      this.clearNextTick();
      this.$render.clearOrgChildren();
      this.initData(rules);
      this.fc.rules = rules;
      this.bus.$once('load-end', function () {
        Object.keys(ctxs).filter(function (id) {
          return _this8.ctxs[id] === undefined;
        }).forEach(function (id) {
          return _this8.rmCtx(ctxs[id]);
        });
3560
        _this8.$render.clearCacheAll();
      });
      this.reloading = true;
      this.loadRule();
      this.reloading = false;
      this.refresh();
      this.bus.$off('next-tick', this.nextReload);
      this.bus.$once('next-tick', this.nextReload);
    },
    //todo 组件生成全部通过 alias
    refresh: function refresh() {
      this.vm._refresh();
    }
  });
}
3576
function fullRule(rule) {
  var def = baseRule();
  Object.keys(def).forEach(function (k) {
    if (!hasProperty(rule, k)) rule[k] = def[k];
  });
  return rule;
}
3584
function getCtrl(ctx) {
  var control = ctx.rule.control || [];
  if (is.Object(control)) return [control];else return control;
}
3589
function findCtrl(ctx, rule) {
  for (var i = 0; i < ctx.ctrlRule.length; i++) {
    var ctrl = ctx.ctrlRule[i];
    if (ctrl.children === rule) return ctrl;
  }
}
3596
function isCtrl(ctx) {
  return !!ctx.rule.__ctrl;
}
3600
function useInput(Handler) {
  extend(Handler.prototype, {
    getValue: function getValue(ctx) {
      if (!hasProperty(ctx, 'cacheValue')) {
        ctx.cacheValue = ctx.parser.toValue(this.getFormData(ctx), ctx);
      }
3607
      return ctx.cacheValue;
    },
    setValue: function setValue(ctx, value, formValue, setFlag) {
      if (ctx.deleted) return;
      ctx.cacheValue = value;
      this.changeStatus = true;
      this.nextRefresh();
      this.$render.clearCache(ctx);
      this.setFormData(ctx, formValue);
      this.syncValue();
      this.valueChange(ctx, value);
      this.vm.$emit('change', ctx.field, value, ctx.origin, this.api, setFlag);
      this.effect(ctx, 'value');
    },
    onInput: function onInput(ctx, value) {
      var val;
3624
      if (ctx.input && (this.isQuote(ctx, val = ctx.parser.toValue(value, ctx)) || this.isChange(ctx, val))) {
        this.setValue(ctx, val, value);
      }
    },
    setFormData: function setFormData(ctx, value) {
      $set(this.formData, ctx.id, value);
    },
    getFormData: function getFormData(ctx) {
      return this.formData[ctx.id];
    },
    validate: function validate() {
      var _this = this;
3637
      toEmpty(this.vm.validate);
      this.fields().forEach(function (id) {
        _this.fieldCtx[id].forEach(function (ctx) {
          _this.vm.validate[ctx.id] = toArray(ctx.rule.validate);
        });
      });
      return this.vm.validate;
    },
    syncForm: function syncForm() {
      var _this2 = this;
3648
      toEmpty(this.form);
      Object.defineProperties(this.form, this.fields().reduce(function (initial, field) {
        var ctx = _this2.getFieldCtx(field);
3652
        var handle = _this2.valueHandle(ctx);
3654
        handle.configurable = true;
        initial[field] = handle;
        return initial;
      }, Object.keys(this.appendData).reduce(function (initial, field) {
        initial[field] = {
          enumerable: true,
          configurable: true,
          get: function get() {
            return _this2.appendData[field];
          },
          set: function set(val) {
            _this2.appendData[field] = val;
          }
        };
        return initial;
      }, {})));
      this.syncValue();
    },
    valueHandle: function valueHandle(ctx) {
      var _this3 = this;
3675
      return {
        enumerable: true,
        get: function get() {
          return _this3.getValue(ctx);
        },
        set: function set(value) {
          if (_this3.isChange(ctx, value)) {
            _this3.setValue(ctx, value, ctx.parser.toFormValue(value, ctx), true);
          }
        }
      };
    },
    appendValue: function appendValue(rule) {
      if (!rule.field || !hasProperty(this.appendData, rule.field)) return;
      rule.value = this.appendData[rule.field];
      delete this.appendData[rule.field];
    },
    addSubForm: function addSubForm(ctx, subForm) {
      if (ctx.input) {
        this.subForm[ctx.id] = subForm;
      }
    },
    deferSyncValue: function deferSyncValue(fn, sync) {
      if (!this.deferSyncFn) {
        this.deferSyncFn = fn;
      }
3702
      if (!this.deferSyncFn.sync) {
        this.deferSyncFn.sync = sync;
      }
3706
      invoke(fn);
3708
      if (this.deferSyncFn === fn) {
        this.deferSyncFn = null;
3711
        if (fn.sync) {
          this.syncValue();
        }
      }
    },
    syncValue: function syncValue() {
      if (this.deferSyncFn) {
        return this.deferSyncFn.sync = true;
      }
3721
      this.vm._updateValue(_objectSpread2({}, this.form));
    },
    isChange: function isChange(ctx, value) {
      return JSON.stringify(ctx.rule.value) !== JSON.stringify(value);
    },
    isQuote: function isQuote(ctx, value) {
      return (is.Object(value) || Array.isArray(value)) && value === ctx.rule.value;
    },
    refreshUpdate: function refreshUpdate(ctx, val) {
      var _this4 = this;
3732
      if (is.Function(ctx.rule.update)) {
        var state = invoke(function () {
          return ctx.rule.update(val, ctx.origin, _this4.api);
        });
        if (state === undefined) return;
        ctx.rule.hidden = state === true;
      }
    },
    valueChange: function valueChange(ctx, val) {
      this.refreshRule(ctx, val);
      this.bus.$emit('change-' + ctx.field, val);
    },
    refreshRule: function refreshRule(ctx, val) {
      if (this.refreshControl(ctx)) {
        this.$render.clearCacheAll();
        this.loadRule();
        this.refresh();
      }
3751
      this.refreshUpdate(ctx, val);
    },
    appendLink: function appendLink(ctx) {
      var _this5 = this;
3756
      var link = ctx.rule.link;
      is.trueArray(link) && link.forEach(function (field) {
        var fn = function fn() {
          return _this5.refreshRule(ctx, ctx.rule.value);
        };
3762
        _this5.bus.$on('change-' + field, fn);
3764
        ctx.linkOn.push(function () {
          return _this5.bus.$off('change-' + field, fn);
        });
      });
    },
    fields: function fields() {
      return Object.keys(this.fieldCtx);
    }
  });
}
3775
function toEmpty(obj) {
  Object.keys(obj).forEach(function (k) {
    return delete obj[k];
  });
}
3781
var BaseParser = {
  init: function init(ctx) {},
  toFormValue: function toFormValue(value, ctx) {
    return value;
  },
  toValue: function toValue(formValue, ctx) {
    return formValue;
  },
  mounted: function mounted(ctx) {},
  render: function render(children, ctx) {
    return ctx.$render.defaultRender(ctx, children);
  },
  mergeProp: function mergeProp(ctx) {}
};
3796
function useContext(Handler) {
  extend(Handler.prototype, {
    getCtx: function getCtx(id) {
      return this.getFieldCtx(id) || this.getNameCtx(id)[0] || this.ctxs[id];
    },
    getCtxs: function getCtxs(id) {
      return this.fieldCtx[id] || this.nameCtx[id] || (this.ctxs[id] ? [this.ctxs[id]] : []);
    },
    setIdCtx: function setIdCtx(ctx, key, type) {
      var field = "".concat(type, "Ctx");
3807
      if (!this[field][key]) {
        this[field][key] = [ctx];
      } else {
        this[field][key].push(ctx);
      }
    },
    rmIdCtx: function rmIdCtx(ctx, key, type) {
      var field = "".concat(type, "Ctx");
      var lst = this[field][key];
      if (!lst) return false;
      var flag = lst.splice(lst.indexOf(ctx) >>> 0, 1).length > 0;
3819
      if (!lst.length) {
        delete this[field][key];
      }
3823
      return flag;
    },
    getFieldCtx: function getFieldCtx(field) {
      return (this.fieldCtx[field] || [])[0];
    },
    getNameCtx: function getNameCtx(name) {
      return this.nameCtx[name] || [];
    },
    setCtx: function setCtx(ctx) {
      var id = ctx.id,
          field = ctx.field,
          name = ctx.name,
          rule = ctx.rule;
      this.ctxs[id] = ctx;
      name && this.setIdCtx(ctx, name, 'name');
      if (!ctx.input) return;
      this.setIdCtx(ctx, field, 'field');
      this.setFormData(ctx, ctx.parser.toFormValue(rule.value, ctx));
3842
      if (this.isMounted && !this.reloading) {
        this.vm.$emit('change', ctx.field, rule.value, ctx.origin, this.api);
      }
    },
    getParser: function getParser(ctx) {
      var list = this.fc.parsers;
      return list[ctx.originType] || list[toCase(ctx.type)] || list[ctx.trueType] || BaseParser;
    },
    bindParser: function bindParser(ctx) {
      ctx.setParser(this.getParser(ctx));
    },
    getType: function getType(alias) {
      var map = this.fc.CreateNode.aliasMap;
      var type = map[alias] || map[toCase(alias)] || alias;
      return toCase(type);
    },
    noWatch: function noWatch(fn) {
      if (!this.noWatchFn) {
        this.noWatchFn = fn;
      }
3863
      invoke(fn);
3865
      if (this.noWatchFn === fn) {
        this.noWatchFn = null;
      }
    },
    watchCtx: function watchCtx(ctx) {
      var _this = this;
3872
      var vm = this.vm;
      var none = ['field', 'value', 'vm', 'template', 'name', 'config', 'control', 'inject', 'sync', 'payload', 'optionsTo', 'update'];
      Object.keys(ctx.rule).filter(function (k) {
        return none.indexOf(k) === -1;
      }).forEach(function (key) {
        var flag = key === 'children';
        ctx.watch.push(vm.$watch(function () {
          return ctx.rule[key];
        }, function (n, o) {
          if (_this.loading || _this.noWatchFn || _this.reloading) return;
3883
          if (flag && ctx.parser.loadChildren === false) {
            _this.$render.clearCache(ctx);
3886
            _this.nextRefresh();
3888
            return;
          }
3891
          _this.watching = true; // if (key === 'hidden')
          //     ctx.updateKey(true);
          // else
3895
          if (key === 'link') {
            ctx.link();
            return;
          } else if (['props', 'on', 'nativeOn', 'deep'].indexOf(key) > -1) {
            _this.parseInjectEvent(ctx.rule, n || {});
3901
            if (key === 'props' && ctx.input) {
              _this.setFormData(ctx, ctx.parser.toFormValue(ctx.rule.value, ctx));
            }
          } else if (['emit', 'nativeEmit'].indexOf(key) > -1) _this.parseEmit(ctx, key === 'emit');else if (['prefix', 'suffix'].indexOf(key) > -1) n && _this.loadFn(n, ctx.rule);else if (key === 'type') {
            ctx.updateType();
3907
            _this.bindParser(ctx);
          } else if (key === 'children') {
            var _flag = is.trueArray(n);
3911
            _this.deferSyncValue(function () {
              if (n !== o) {
                _this.rmSub(o);
3915
                _this.$render.initOrgChildren();
              }
3918
              _flag && _this.loadChildren(n, ctx);
            });
          }
3922
          _this.$render.clearCache(ctx);
3924
          _this.watching = false;
        }, {
          deep: !flag,
          sync: flag
        }));
      });
      this.watchEffect(ctx);
    },
    rmSub: function rmSub(sub) {
      var _this2 = this;
3935
      is.trueArray(sub) && sub.forEach(function (r) {
        r && r.__fc__ && _this2.rmCtx(r.__fc__);
      });
    },
    rmCtx: function rmCtx(ctx) {
      var _this3 = this;
3942
      if (ctx.deleted) return;
      var id = ctx.id,
          field = ctx.field,
          input = ctx.input,
          name = ctx.name;
3948
      if (ctx.input) {
        Object.defineProperty(ctx.rule, 'value', {
          value: ctx.rule.value,
          writable: true
        });
      }
3955
      $del(this.ctxs, id);
      $del(this.$render.tempList, id);
      $del(this.$render.orgChildren, id);
      $del(this.vm.ctxInject, id);
      $del(this.formData, id);
      $del(this.subForm, id);
      $del(ctx, 'cacheValue');
      input && this.rmIdCtx(ctx, field, 'field');
      name && this.rmIdCtx(ctx, name, 'name');
      this.deferSyncValue(function () {
        if (!_this3.reloading) {
          if (ctx.parser.loadChildren !== false) {
            if (is.trueArray(ctx.rule.children)) {
              ctx.rule.children.forEach(function (h) {
                return h.__fc__ && _this3.rmCtx(h.__fc__);
              });
            }
          }
3974
          if (ctx.root === _this3.rules) {
            _this3.vm._renderRule();
          }
        }
      }, input);
      var index = this.sort.indexOf(id);
3981
      if (index > -1) {
        this.sort.splice(index, 1);
      }
3985
      this.$render.clearCache(ctx);
      ctx["delete"]();
      this.effect(ctx, 'deleted');
      input && !this.fieldCtx[field] && this.vm.$emit('removeField', field, ctx.rule, this.api);
      ctx.rule.__ctrl || this.vm.$emit('removeRule', ctx.rule, this.api);
      return ctx;
    }
  });
}
3995
function useLifecycle(Handler) {
  extend(Handler.prototype, {
    mounted: function mounted() {
      var _this = this;
4000
      var _mounted = function _mounted() {
        _this.isMounted = true;
4003
        _this.lifecycle('mounted');
      };
4006
      if (this.pageEnd) {
        _mounted();
      } else {
        this.bus.$once('page-end', _mounted);
      }
    },
    lifecycle: function lifecycle(name) {
      var _this2 = this;
4015
      var fn = this.options[name];
      is.Function(fn) && invoke(function () {
        return fn(_this2.api);
      });
      this.vm.$emit(name, this.api);
    }
  });
}
4024
function useEffect(Handler) {
  extend(Handler.prototype, {
    useProvider: function useProvider() {
      var _this = this;
4029
      var ps = this.fc.providers;
      Object.keys(ps).forEach(function (k) {
        var prop = ps[k];
        prop._c = getComponent(prop);
4034
        _this.onEffect(prop);
4036
        _this.providers[k] = prop;
      });
    },
    onEffect: function onEffect(provider) {
      var _this2 = this;
4042
      var used = [];
      (provider._c || ['*']).forEach(function (name) {
        var type = name === '*' ? '*' : _this2.getType(name);
        if (used.indexOf(type) > -1) return;
        used.push(type);
4048
        _this2.bus.$on("p:".concat(provider.name, ":").concat(type, ":").concat(provider.input ? 1 : 0), function (event, args) {
          provider[event] && provider[event].apply(provider, _toConsumableArray(args));
        });
      });
      provider._used = used;
    },
    watchEffect: function watchEffect(ctx) {
      var _this3 = this;
4057
      var vm = this.vm;
      Object.keys(ctx.rule.effect || {}).forEach(function (k) {
        ctx.watch.push(vm.$watch(function () {
          return ctx.rule.effect[k];
        }, function (n) {
          _this3.effect(ctx, 'watch', _defineProperty({}, k, n));
        }, {
          deep: true
        }));
      });
    },
    ruleEffect: function ruleEffect(rule, event, append) {
      this.emitEffect({
        rule: rule,
        input: !!rule.field,
        type: this.getType(rule.type)
      }, event, append);
    },
    effect: function effect(ctx, event, custom) {
      this.emitEffect({
        rule: ctx.rule,
        input: ctx.input,
        type: ctx.trueType,
        ctx: ctx,
        custom: custom
      }, event);
    },
    getEffect: function getEffect(rule, name) {
      if (hasProperty(rule, 'effect') && hasProperty(rule.effect, name)) return rule.effect[name];else return undefined;
    },
    emitEffect: function emitEffect(_ref, event, append) {
      var _this4 = this;
4090
      var ctx = _ref.ctx,
          rule = _ref.rule,
          input = _ref.input,
          type = _ref.type,
          custom = _ref.custom;
      if (!type || type === 'fcFragment') return;
      var effect = custom ? custom : rule.effect || {};
      Object.keys(effect).forEach(function (attr) {
        var p = _this4.providers[attr];
        if (!p || p.input && !input) return;
4101
        var _type;
4103
        if (!p._c) {
          _type = '*';
        } else if (p._used.indexOf(type) > -1) {
          _type = type;
        } else {
          return;
        }
4111
        var data = _objectSpread2({
          value: effect[attr],
          getValue: function getValue() {
            return _this4.getEffect(rule, attr);
          }
        }, append || {});
4118
        if (ctx) {
          data.getProp = function () {
            return ctx.effectData(attr);
          };
4123
          data.clearProp = function () {
            return ctx.clearEffectData(attr);
          };
4127
          data.mergeProp = function (prop) {
            return mergeProps([prop], data.getProp());
          };
        }
4132
        _this4.bus.$emit("p:".concat(attr, ":").concat(_type, ":").concat(p.input ? 1 : 0), event, [data, rule, _this4.api]);
      });
    }
  });
}
4138
function unique(arr) {
  return arr.filter(function (item, index, arr) {
    return arr.indexOf(item, 0) === index;
  });
}
4144
function getComponent(p) {
  var c = p.components;
  if (Array.isArray(c)) return unique(c.filter(function (v) {
    return v !== '*';
  }));else if (is.String(c)) return [c];else return false;
}
4151
function Handler(fc) {
  var _this = this;
4154
  extend(this, {
    fc: fc,
    vm: fc.vm,
    watching: false,
    loading: false,
    reloading: false,
    noWatchFn: null,
    deferSyncFn: null,
    isMounted: false,
    formData: {},
    subForm: {},
    form: {},
    appendData: {},
    providers: {},
    cycleLoad: null,
    loadedId: 1,
    nextTick: null,
    changeStatus: false,
    pageEnd: true,
    nextReload: function nextReload() {
      _this.lifecycle('reload');
    }
  });
  funcProxy(this, {
    options: function options() {
      return fc.options;
    },
    bus: function bus() {
      return fc.bus;
    }
  });
  this.initData(fc.rules);
  this.$manager = new fc.manager(this);
  this.$render = new Render(this);
  this.api = fc.extendApi(Api(this), this);
}
extend(Handler.prototype, {
  initData: function initData(rules) {
    extend(this, {
      ctxs: {},
      fieldCtx: {},
      nameCtx: {},
      sort: [],
      rules: rules
    });
  },
  init: function init() {
    this.appendData = _objectSpread2(_objectSpread2(_objectSpread2({}, this.fc.options.formData || {}), this.vm.value || {}), this.appendData);
    this.useProvider();
    this.usePage();
    this.loadRule();
4206
    this.$manager.__init();
4208
    this.vm.$set(this.vm, 'formData', this.formData);
  }
});
useInject(Handler);
usePage(Handler);
useRender$1(Handler);
useLoader(Handler);
useInput(Handler);
useContext(Handler);
useLifecycle(Handler);
useEffect(Handler);
4220
// https://github.com/ElemeFE/element/blob/dev/packages/upload/src/ajax.js
function getError(action, option, xhr) {
  var msg = "fail to ".concat(action, " ").concat(xhr.status, "'");
  var err = new Error(msg);
  err.status = xhr.status;
  err.url = action;
  return err;
}
4229
function getBody(xhr) {
  var text = xhr.responseText || xhr.response;
4232
  if (!text) {
    return text;
  }
4236
  try {
    return JSON.parse(text);
  } catch (e) {
    return text;
  }
}
4243
function fetch(option) {
  if (typeof XMLHttpRequest === 'undefined') {
    return;
  }
4248
  var xhr = new XMLHttpRequest();
  var action = option.action;
4251
  xhr.onerror = function error(e) {
    option.onError(e);
  };
4255
  xhr.onload = function onload() {
    if (xhr.status < 200 || xhr.status >= 300) {
      return option.onError(getError(action, option, xhr), getBody(xhr));
    }
4260
    option.onSuccess(getBody(xhr));
  };
4263
  xhr.open(option.method || 'get', action, true);
  var formData;
4266
  if (option.data) {
    if ((option.dataType || '').toLowerCase() !== 'json') {
      formData = new FormData();
      Object.keys(option.data).map(function (key) {
        formData.append(key, option.data[key]);
      });
    } else {
      formData = JSON.stringify(option.data);
      xhr.setRequestHeader('content-type', 'application/json');
    }
  }
4278
  if (option.withCredentials && 'withCredentials' in xhr) {
    xhr.withCredentials = true;
  }
4282
  var headers = option.headers || {};
  Object.keys(headers).forEach(function (item) {
    if (headers[item] !== null) {
      xhr.setRequestHeader(item, headers[item]);
    }
  });
  xhr.send(formData);
}
4291
var NAME$5 = 'fcFragment';
var fragment = {
  name: NAME$5,
  functional: true,
  props: ['vnode'],
  render: function render(h, ctx) {
    return ctx.props.vnode ? ctx.props.vnode : ctx.children;
  }
};
4301
function parseProp(prop) {
  if (is.String(prop)) return {
    domProps: {
      innerHTML: prop
    }
  };
  return prop;
}
4310
function CreateNodeFactory() {
  var aliasMap = {};
4313
  function CreateNode(vm) {
    vm && this.setVm(vm);
  }
4317
  extend(CreateNode.prototype, {
    setVm: function setVm(vm) {
      this.vm = vm;
      this.$h = vm.$createElement;
    },
    make: function make(tag, data, children) {
      if (Vue.config.isReservedTag(tag) && data.nativeOn) delete data.nativeOn;
      var Node = this.$h(tag, parseProp(data), children || []);
      Node.context = this.vm;
      return Node;
    },
    aliasMap: aliasMap
  });
  extend(CreateNode, {
    aliasMap: aliasMap,
    alias: function alias(_alias, name) {
      aliasMap[_alias] = name;
    },
    use: function use(nodes) {
      Object.keys(nodes).forEach(function (k) {
        var line = toLine(k);
        var lower = toString(k).toLocaleLowerCase();
        var v = nodes[k];
        [k, line, lower].forEach(function (n) {
          CreateNode.alias(k, v);
4343
          CreateNode.prototype[n] = function (data, children) {
            return this.make(v, data, children);
          };
        });
      });
    }
  });
  return CreateNode;
}
4353
function createManager(proto) {
  var CustomManager = /*#__PURE__*/function (_Manager) {
    _inherits(CustomManager, _Manager);
4357
    var _super = _createSuper(CustomManager);
4359
    function CustomManager() {
      _classCallCheck(this, CustomManager);
4362
      return _super.apply(this, arguments);
    }
4365
    return CustomManager;
  }(Manager);
4368
  Object.assign(CustomManager.prototype, proto);
  return CustomManager;
}
function Manager(handler) {
  extend(this, {
    $handle: handler,
    vm: handler.vm,
    options: {},
    ref: 'fcForm',
    mergeOptionsRule: {
      normal: ['form', 'row', 'info', 'submitBtn', 'resetBtn']
    }
  });
  this.updateKey();
  this.init();
}
extend(Manager.prototype, {
  __init: function __init() {
    var _this = this;
4388
    this.$render = this.$handle.$render;
4390
    this.$r = function () {
      var _this$$render;
4393
      return (_this$$render = _this.$render).renderRule.apply(_this$$render, arguments);
    };
  },
  updateKey: function updateKey() {
    this.key = uniqueId();
  },
  //TODO interface
  init: function init() {},
  update: function update() {},
  beforeRender: function beforeRender() {},
  form: function form() {
    return this.vm.$refs[this.ref];
  },
  mergeOptions: function mergeOptions(args, opt) {
    var _this2 = this;
4409
    return mergeProps(args.map(function (v) {
      return _this2.tidyOptions(v);
    }), opt, this.mergeOptionsRule);
  },
  updateOptions: function updateOptions(options) {
    this.options = this.mergeOptions([options], this.getDefaultOptions());
    this.update();
  },
  tidyOptions: function tidyOptions(options) {
    return options;
  },
  tidyRule: function tidyRule(ctx) {},
  mergeProp: function mergeProp(ctx) {},
  getDefaultOptions: function getDefaultOptions() {
    return {};
  },
  render: function render(children) {}
});
4428
var $fetch = {
  name: 'fetch',
  loaded: function loaded() {
    run.apply(void 0, arguments);
  },
  watch: function watch(inject, rule, api) {
    if (!run(inject, rule, api)) {
      inject.clearProp();
      api.sync(rule);
    }
  }
};
4441
function parseOpt(option) {
  if (is.String(option)) {
    option = {
      action: option,
      to: 'options'
    };
  }
4449
  return option;
}
4452
function run(inject, rule, api) {
  var option = inject.value;
  option = parseOpt(option);
4456
  if (!option || !option.action) {
    return false;
  }
4460
  if (!option.to) {
    option.to = 'options';
  }
4464
  var _onError = option.onError;
4466
  var check = function check() {
    if (!inject.getValue()) {
      inject.clearProp();
      api.sync(rule);
      return true;
    }
  };
4474
  var set = function set(val) {
    if (val === undefined) {
      inject.clearProp();
      api.sync(rule);
    } else {
      deepSet(inject.getProp(), option.to, val);
    }
  };
4483
  invoke(function () {
    return fetch(_objectSpread2(_objectSpread2({}, option), {}, {
      onSuccess: function onSuccess(body) {
        if (check()) return;
        set((option.parse || function (v) {
          return v.data;
        })(body, rule, api));
        api.sync(rule);
      },
      onError: function onError(e) {
        set(undefined);
        if (check()) return;
4496
        (_onError || function (e) {
          return err(e.message || 'fetch fail ' + option.action);
        })(e, rule, api);
      }
    }));
  });
  return true;
}
4505
var _vue = typeof window !== 'undefined' && window.Vue ? window.Vue : Vue;
4507
function _parseProp(name, id) {
  var prop;
4510
  if (arguments.length === 2) {
    prop = arguments[1];
    id = prop[name];
  } else {
    prop = arguments[2];
  }
4517
  return {
    id: id,
    prop: prop
  };
}
4523
function nameProp() {
  return _parseProp.apply(void 0, ['name'].concat(Array.prototype.slice.call(arguments)));
}
4527
function _getEl(options) {
  if (!options || !options.el) return window.document.body;
  return is.Element(options.el) ? options.el : document.querySelector(options.el);
}
4532
function mountForm(rules, option) {
  var $vm = new _vue({
    data: function data() {
      //todo 外部无法修改
      return {
        rule: rules,
        option: option || {}
      };
    },
    render: function render(h) {
      return h('FormCreate', {
        ref: 'fc',
        props: this.$data
      });
    }
  });
  $vm.$mount();
  return $vm;
}
4552
function exportAttrs(attrs) {
  var key = attrs.key || [];
  var array = attrs.array || [];
  var normal = attrs.normal || [];
  keyAttrs.push.apply(keyAttrs, _toConsumableArray(key));
  arrayAttrs.push.apply(arrayAttrs, _toConsumableArray(array));
  normalAttrs.push.apply(normalAttrs, _toConsumableArray(normal));
  appendProto([].concat(_toConsumableArray(key), _toConsumableArray(array), _toConsumableArray(normal)));
} //todo 表单嵌套
4562
4563
function FormCreateFactory(config) {
  var _fragment = _vue.extend(fragment);
4566
  var components = _defineProperty({}, fragment.name, _fragment);
4568
  var parsers = {};
  var directives = {};
  var providers = {
    fetch: $fetch
  };
  var maker = makerFactory();
  var globalConfig = {
    global: {}
  };
  var data = {};
  var CreateNode = CreateNodeFactory();
  exportAttrs(config.attrs || {});
4581
  function directive() {
    var data = nameProp.apply(void 0, arguments);
    if (data.id && data.prop) directives[data.id] = data.prop;
  }
4586
  function register() {
    var data = nameProp.apply(void 0, arguments);
    if (data.id && data.prop) providers[data.id] = _objectSpread2(_objectSpread2({}, data.prop), {}, {
      name: data.id
    });
  }
4593
  function componentAlias(alias) {
    CreateNode.use(alias);
  }
4597
  function parser() {
    var data = nameProp.apply(void 0, arguments);
    if (!data.id || !data.prop) return;
    var name = toCase(data.id);
    var parser = data.prop;
    var base = parser.merge === true ? parsers[name] : undefined;
    parsers[name] = _objectSpread2(_objectSpread2({}, base || BaseParser), parser);
    maker[name] = creatorFactory(name);
    parser.maker && extend(maker, parser.maker);
  }
4608
  function component(id, component) {
    var name;
4611
    if (is.String(id)) {
      name = toCase(id);
4614
      if (['form-create', 'formcreate'].indexOf(name) > -1) {
        return $form();
      } else if (component === undefined) {
        return components[name];
      }
    } else {
      name = toCase(id.name);
      component = id;
    }
4624
    if (!name || !component) return;
    components[name] = component;
    if (component.formCreateParser) parser(name, component.formCreateParser);
  }
4629
  function $form() {
    return _vue.extend($FormCreate(FormCreate));
  } //todo 检查回调函数作用域
4633
4634
  function use(fn, opt) {
    if (is.Function(fn.install)) fn.install(create, opt);else if (is.Function(fn)) fn(create, opt);
    return this;
  }
4639
  function create(rules, _opt, parent) {
    var $vm = mountForm(rules, _opt || {});
    var _this = $vm.$refs.fc.formCreate;
    _this.$parent = parent;
4644
    _getEl(_this.options).appendChild($vm.$el);
4646
    return _this.api();
  }
4649
  function factory() {
    return FormCreateFactory(config);
  }
4653
  function FormCreate(vm, rules, options) {
    extend(this, {
      vm: vm,
      create: create,
      manager: createManager(config.manager),
      parsers: parsers,
      providers: providers,
      rules: Array.isArray(rules) ? rules : [],
      prop: {
        components: components,
        directives: directives
      },
      CreateNode: CreateNode,
      bus: new _vue(),
      unwatch: null,
      extendApi: config.extendApi || function (api) {
        return api;
      }
    });
    this.init();
    this.initOptions(options || {});
  }
4676
  extend(FormCreate.prototype, {
    init: function init() {
      var _this2 = this;
4680
      var vm = this.vm;
      var h = new Handler(this);
      this.$handle = h;
      vm.$f = h.api;
      vm.$emit('input', h.api);
      vm.$on('hook:created', function () {
        if (_this2.isSub()) {
          _this2.unwatch = vm.$watch(function () {
            return vm.$pfc.option;
          }, function () {
            _this2.initOptions(_this2.options);
4692
            vm.$f.refresh();
          }, {
            deep: true
          });
4697
          _this2.initOptions(_this2.options);
        }
4700
        _this2.created();
      });
      vm.$on('hook:mounted', function () {
        _this2.mounted();
      });
      vm.$on('hook:beforeDestroy', function () {
        vm.destroyed = true;
        _this2.unwatch && _this2.unwatch();
        h.reloadRule([]);
      });
      vm.$on('hook:updated', function () {
        h.bindNextTick(function () {
          return _this2.bus.$emit('next-tick', h.api);
        });
      });
    },
    isSub: function isSub() {
      return this.vm.$pfc && this.vm.extendOption;
    },
    initOptions: function initOptions(options) {
      this.options = _objectSpread2({
        formData: {},
        submitBtn: {},
        resetBtn: {}
      }, deepCopy(globalConfig));
4726
      if (this.isSub()) {
        this.mergeOptions(this.options, this.vm.$pfc.$f.config || {}, true);
      }
4730
      this.updateOptions(options);
    },
    mergeOptions: function mergeOptions(target, opt, parent) {
      opt = deepCopy(opt);
      parent && ['page', 'onSubmit', 'mounted', 'reload', 'formData', 'el'].forEach(function (n) {
        delete opt[n];
      });
4738
      if (opt.global) {
        target.global = mergeGlobal(target.global, opt.global);
        delete opt.global;
      }
4743
      this.$handle.$manager.mergeOptions([opt], target);
      return target;
    },
    updateOptions: function updateOptions(options) {
      this.mergeOptions(this.options, options);
      this.$handle.$manager.updateOptions(this.options);
    },
    created: function created() {
      this.$handle.init();
    },
    api: function api() {
      return this.$handle.api;
    },
    render: function render() {
      return this.$handle.render();
    },
    mounted: function mounted() {
      this.$handle.mounted();
    }
  });
4764
  function useAttr(formCreate) {
    extend(formCreate, {
      version: config.version,
      ui: config.ui,
      data: data,
      maker: maker,
      component: component,
      directive: directive,
      register: register,
      fragment: _fragment,
      parser: parser,
      use: use,
      factory: factory,
      componentAlias: componentAlias,
      copyRule: copyRule,
      copyRules: copyRules,
      fetch: fetch,
      $form: $form,
      parseJson: parseJson,
      toJson: toJson,
      init: function init(rules) {
        var _opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
4787
        var $vm = mountForm(rules, _opt),
            _this = $vm.$refs.fc.formCreate;
        return {
          mount: function mount($el) {
            if ($el && is.Element($el)) _this.options.el = $el;
4793
            _getEl(_this.options).appendChild($vm.$el);
4795
            return _this.api();
          },
          remove: function remove() {
            $vm.$el.parentNode && $vm.$el.parentNode.removeChild($vm.$el);
          },
          destroy: function destroy() {
            this.remove();
            $vm.$destroy();
          },
          $f: _this.api()
        };
      }
    });
  }
4810
  function useStatic(formCreate) {
    extend(formCreate, {
      create: create,
      install: function install(Vue, options) {
        globalConfig = _objectSpread2(_objectSpread2({}, globalConfig), options || {});
        if (Vue._installedFormCreate === true) return;
        Vue._installedFormCreate = true;
        _vue = Vue;
4819
        var $formCreate = function $formCreate(rules) {
          var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return create(rules, opt, this);
        };
4824
        useAttr($formCreate);
        Vue.prototype.$formCreate = $formCreate;
        Vue.component('FormCreate', $form());
        Vue.component('FcFragment', _fragment);
      }
    });
  }
4832
  useAttr(create);
  useStatic(create);
  CreateNode.use({
    fragment: 'fcFragment'
  });
  if (config.install) create.use(config);
  return create;
}
4841
var FORMAT_TYPE = {
  date: 'YYYY-MM-DD',
  month: 'YYYY-MM',
  week: 'YYYY-wo',
  range: 'YYYY-MM-DD HH:mm:ss'
};
4848
var getType = function getType(ctx) {
  var type = ctx.prop.props.type;
  if (['date', 'month', 'week', 'range'].indexOf(type) === -1) return 'date';
  return type;
};
4854
var toMoment = function toMoment(val) {
  return val instanceof moment ? val : moment(val);
};
4858
function getFormat(ctx) {
  return ctx.prop.props.format || (ctx.el ? ctx.el.format : '') || FORMAT_TYPE[getType(ctx)];
}
4862
var name$1 = 'datePicker';
var datePicker = {
  name: name$1,
  maker: function () {
    return ['date', 'month', 'week'].reduce(function (initial, type) {
      initial[type] = creatorFactory(name$1, {
        type: type
      });
      return initial;
    }, {
      dateRange: creatorFactory(name$1, {
        type: 'range'
      }),
      datetimeRange: creatorFactory(name$1, function (m) {
        return m.props({
          type: 'range',
          showTime: true
        });
      })
    });
  }(),
  toFormValue: function toFormValue(value, ctx) {
    var parseValue,
        type = getType(ctx);
    var isArr = Array.isArray(value);
4888
    if (type === 'range') {
      if (isArr) {
        parseValue = value.map(function (v) {
          return v ? toMoment(v) : null;
        });
      } else {
        parseValue = [];
      }
    } else {
      parseValue = isArr ? (value[0] ? toMoment(value[0]) : null) || null : value ? toMoment(value) : null;
    }
4900
    return parseValue;
  },
  toValue: function toValue(formValue, ctx) {
    var format = getFormat(ctx);
    if (Array.isArray(formValue)) return formValue.map(function (v) {
      return v ? v.format(format) : v;
    });else return formValue ? formValue.format(format) : formValue;
  },
  render: function render(children, ctx) {
    var type = getType(ctx) + 'Picker';
    return ctx.$render.vNode[type](ctx.prop, children);
  }
};
4914
var name$2 = 'hidden';
var hidden = {
  name: name$2,
  maker: _defineProperty({}, name$2, function (field, value) {
    return creatorFactory(name$2)('', field, value);
  }),
  render: function render() {
    return [];
  }
};
4925
var name$3 = 'input';
var input = {
  name: name$3,
  maker: function () {
    return ['password', 'url', 'email', 'text', 'textarea', 'search'].reduce(function (maker, type) {
      maker[type] = creatorFactory(name$3, {
        type: type
      });
      return maker;
    }, {
      idate: creatorFactory(name$3, {
        type: 'date'
      })
    });
  }(),
  render: function render(children, ctx) {
    var type = ctx.prop.props.type;
    if (['textarea', 'search'].indexOf(type) === -1) type = 'input';
    type = type === 'textarea' ? 'ATextarea' : type === 'search' ? 'AInputSearch' : 'AInput';
    return ctx.$render.vNode.make(type, ctx.prop, children);
  }
};
4948
var toMoment$1 = function toMoment(val, format) {
  return val instanceof moment ? val : moment(val, format);
};
4952
function getFormat$1(ctx) {
  return ctx.prop.props.format || (ctx.el ? ctx.el.format : '') || 'HH:mm:ss';
}
4956
var timePicker = {
  name: 'timePicker',
  toFormValue: function toFormValue(value, ctx) {
    return value ? toMoment$1(value, getFormat$1(ctx)) : null;
  },
  toValue: function toValue(formValue, ctx) {
    return formValue ? formValue.format(getFormat$1(ctx)) : formValue;
  }
};
4966
var tree = {
  name: 'tree',
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;
    if (!props.replaceFields) props.replaceFields = {
      key: 'id'
    };else if (!props.replaceFields.key) props.replaceFields.key = 'id';
    props.checkedKeys = ctx.rule.value;
    props.checkable = true;
  }
};
4978
var row = {
  name: 'FcRow',
  render: function render(_, ctx) {
    return ctx.vNode.col({
      props: {
        span: 24
      }
    }, [ctx.vNode.row(ctx.prop, _)]);
  }
};
4989
var parsers = [checkbox, datePicker, hidden, input, timePicker, tree, radio, select, row];
4991
var PRE = 'a';
var alias = {
  tooltip: PRE + 'Tooltip',
  popover: PRE + 'Popover',
  button: PRE + 'Button',
  icon: PRE + 'Icon',
  slider: PRE + 'Slider',
  rate: PRE + 'Rate',
  upload: 'fcUpload',
  cascader: PRE + 'Cascader',
  timePicker: PRE + 'TimePicker',
  datePicker: PRE + 'DatePicker',
  rangePicker: PRE + 'RangePicker',
  weekPicker: PRE + 'WeekPicker',
  monthPicker: PRE + 'MonthPicker',
  'switch': PRE + 'Switch',
  select: PRE + 'Select',
  checkbox: PRE + 'CheckboxGroup',
  radio: PRE + 'RadioGroup',
  inputNumber: PRE + 'InputNumber',
  search: PRE + 'InputSearch',
  textarea: PRE + 'Textarea',
  formItem: PRE + 'FormModelItem',
  form: PRE + 'FormModel',
  frame: 'fcFrame',
  col: PRE + 'Col',
  row: PRE + 'Row',
  tree: PRE + 'Tree',
  autoComplete: PRE + 'AutoComplete',
  group: 'fcGroup',
  subForm: 'fcSubForm',
  object: 'fcSubForm'
};
5025
var UNDEF = undefined;
function getConfig() {
  return {
    form: {
      hideRequiredMark: false,
      layout: 'horizontal',
      labelAlign: 'right',
      labelCol: {
        span: 3
      },
      wrapperCol: {
        span: 21
      },
      validateOnRuleChange: true
    },
    row: {
      gutter: 0
    },
    submitBtn: {
      disabled: false,
      loading: false,
      type: 'primary',
      innerText: '提交',
      show: true,
      col: UNDEF,
      click: UNDEF
    },
    resetBtn: {
      disabled: false,
      icon: 'sync',
      loading: false,
      type: 'default',
      innerText: '重置',
      show: false,
      col: UNDEF,
      click: UNDEF
    }
  };
}
5065
function isTooltip(info) {
  return info.type === 'tooltip';
}
5069
function tidy(props, name) {
  if (!hasProperty(props, name)) return;
5072
  if (is.String(props[name])) {
    var _props$name;
5075
    props[name] = (_props$name = {}, _defineProperty(_props$name, name, props[name]), _defineProperty(_props$name, "show", true), _props$name);
  }
}
5079
function isFalse(val) {
  return val === false;
}
5083
function tidyBool(opt, name) {
  if (hasProperty(opt, name) && !is.Object(opt[name])) {
    opt[name] = {
      show: !!opt[name]
    };
  }
}
5091
var manager = {
  validate: function validate(call) {
    this.form().validate(call);
  },
  validateField: function validateField(field, call) {
    this.form().validateField(field, call);
  },
  clearValidateState: function clearValidateState(ctx) {
    var fItem = this.vm.$refs[ctx.wrapRef];
5101
    if (fItem) {
      fItem.validateMessage = '';
      fItem.validateState = '';
    }
  },
  tidyOptions: function tidyOptions(options) {
    ['submitBtn', 'resetBtn', 'row', 'info', 'wrap', 'col'].forEach(function (name) {
      tidyBool(options, name);
    });
    return options;
  },
  tidyRule: function tidyRule(_ref) {
    var prop = _ref.prop;
    tidy(prop, 'title');
    tidy(prop, 'info');
    return prop;
  },
  mergeProp: function mergeProp(ctx) {
    ctx.prop = mergeProps([{
      info: this.options.info || {},
      wrap: this.options.wrap || {},
      col: this.options.col || {}
    }, ctx.prop], {
      info: {
        type: 'popover',
        placement: 'topLeft',
        icon: 'question-circle-o'
      },
      title: {},
      col: {
        span: 24
      },
      wrap: {}
    }, {
      normal: ['title', 'info', 'col', 'wrap']
    });
  },
  getDefaultOptions: function getDefaultOptions() {
    return getConfig();
  },
  update: function update() {
    var form = this.options.form;
    this.rule = {
      props: _objectSpread2({}, form),
      nativeOn: {
        submit: function submit(e) {
          e.preventDefault();
        }
      },
      "class": [form.className, form["class"], 'form-create'],
      style: form.style,
      type: 'form'
    };
  },
  beforeRender: function beforeRender() {
    var key = this.key,
        ref = this.ref,
        $handle = this.$handle;
    extend(this.rule, {
      key: key,
      ref: ref
    });
    extend(this.rule.props, {
      model: $handle.formData,
      rules: $handle.validate()
    });
  },
  render: function render(children) {
    if (children.length) {
      children.push(this.makeFormBtn());
    }
5173
    return this.$r(this.rule, isFalse(this.options.row.show) ? children : [this.makeRow(children)]);
  },
  makeWrap: function makeWrap(ctx, children) {
    var rule = ctx.prop;
    var uni = "".concat(this.key).concat(ctx.key);
    var col = rule.col;
    var _this$rule$props = this.rule.props,
        layout = _this$rule$props.layout,
        _col = _this$rule$props.col;
    var item = isFalse(rule.wrap.show) ? children : this.$r(mergeProps([rule.wrap, {
      props: _objectSpread2(_objectSpread2({}, rule.wrap || {}), {}, {
        prop: ctx.id,
        rules: rule.validate
      }, layout !== 'horizontal' ? {
        labelCol: {},
        wrapperCol: {}
      } : {}),
      "class": rule.className,
      key: "".concat(uni, "fi"),
      ref: ctx.wrapRef,
      type: 'formItem'
    }]), [children, this.makeInfo(rule, uni)]);
    return layout === 'inline' || isFalse(_col) || isFalse(col.show) ? item : this.makeCol(rule, uni, [item]);
  },
  makeInfo: function makeInfo(rule, uni) {
    var _this = this;
5200
    var titleProp = rule.title;
    var infoProp = rule.info;
    if (this.options.form.title === false) return false;
    if (!titleProp.title && !titleProp["native"] || isFalse(titleProp.show)) return;
    var isTool = isTooltip(infoProp);
    var children = [titleProp.title];
5207
    var titleFn = function titleFn(pop) {
      return _this.$r(mergeProps([titleProp, {
        props: titleProp,
        slot: titleProp.slot || (pop ? 'default' : 'label'),
        key: "".concat(uni, "tit"),
        type: titleProp.type || 'span'
      }]), children);
    };
5216
    if (!isFalse(infoProp.show) && (infoProp.info || infoProp["native"])) {
      if (infoProp.icon !== false) {
        children[infoProp.align !== 'left' ? 'unshift' : 'push'](this.$r({
          type: 'icon',
          props: {
            type: infoProp.icon === true ? 'question-circle-o' : infoProp.icon
          },
          key: "".concat(uni, "i")
        }));
      }
5227
      var prop = {
        type: infoProp.type || 'popover',
        props: _objectSpread2({}, infoProp),
        key: "".concat(uni, "pop"),
        slot: 'label'
      };
      var field = isTool ? 'title' : 'content';
5235
      if (infoProp.info && !hasProperty(prop.props, field)) {
        prop.props[field] = infoProp.info;
      }
5239
      return this.$r(mergeProps([infoProp, prop]), [titleFn(true)]);
    }
5242
    return titleFn();
  },
  makeCol: function makeCol(rule, uni, children) {
    var col = rule.col;
    return this.$r({
      "class": col["class"],
      type: 'col',
      props: col || {
        span: 24
      },
      key: "".concat(uni, "col")
    }, children);
  },
  makeRow: function makeRow(children) {
    var row = this.options.row || {};
    return this.$r({
      type: 'row',
      props: row,
      "class": row["class"],
      key: "".concat(this.key, "row")
    }, children);
  },
  makeFormBtn: function makeFormBtn() {
    var vn = [];
5267
    if (!isFalse(this.options.submitBtn.show)) {
      vn.push(this.makeSubmitBtn());
    }
5271
    if (!isFalse(this.options.resetBtn.show)) {
      vn.push(this.makeResetBtn());
    }
5275
    if (!vn.length) {
      return;
    }
5279
    var _this$rule$props2 = this.rule.props,
        labelCol = _this$rule$props2.labelCol,
        wrapperCol = _this$rule$props2.wrapperCol,
        layout = _this$rule$props2.layout;
5284
    if (layout !== 'horizontal') {
      labelCol = wrapperCol = {};
    }
5288
    var item = this.$r({
      type: 'formItem',
      key: "".concat(this.key, "fb"),
      props: {
        labelCol: labelCol,
        wrapperCol: wrapperCol,
        label: ' ',
        colon: false
      }
    }, vn);
    return layout === 'inline' ? item : this.$r({
      type: 'col',
      props: {
        span: 24
      },
      key: "".concat(this.key, "fc")
    }, [item]);
  },
  makeResetBtn: function makeResetBtn() {
    var _this2 = this;
5309
    var resetBtn = this.options.resetBtn;
    return this.$r({
      type: 'button',
      props: resetBtn,
      style: {
        width: resetBtn.width,
        marginLeft: '10px'
      },
      on: {
        click: function click() {
          var fApi = _this2.$handle.api;
          resetBtn.click ? resetBtn.click(fApi) : fApi.resetFields();
        }
      },
      key: "".concat(this.key, "b2")
    }, [resetBtn.innerText]);
  },
  makeSubmitBtn: function makeSubmitBtn() {
    var _this3 = this;
5329
    var submitBtn = this.options.submitBtn;
    return this.$r({
      type: 'button',
      props: submitBtn,
      style: {
        width: submitBtn.width
      },
      on: {
        click: function click() {
          var fApi = _this3.$handle.api;
          submitBtn.click ? submitBtn.click(fApi) : fApi.submit();
        }
      },
      key: "".concat(this.key, "b1")
    }, [submitBtn.innerText]);
  }
};
5347
var maker = {};
5349
function useAlias(maker) {
  ['upload', 'frame', 'autoComplete', 'cascader', 'datePicker', 'frame', 'inputNumber', 'radio', 'rate', 'switch', 'rate', 'slider', 'timePicker'].reduce(function (maker, name) {
    maker[name] = creatorFactory(name);
    return maker;
  }, maker);
  maker.auto = maker.autoComplete;
  maker.number = maker.inputNumber;
  maker.time = maker.timePicker;
}
5359
function useFrame(maker) {
  var types = {
    frameInputs: ['input', 0],
    frameFiles: ['file', 0],
    frameImages: ['image', 0],
    frameInputOne: ['input', 1],
    frameFileOne: ['file', 1],
    frameImageOne: ['image', 1]
  };
  Object.keys(types).reduce(function (maker, key) {
    maker[key] = creatorFactory('frame', function (m) {
      return m.props({
        type: types[key][0],
        maxLength: types[key][1]
      });
    });
    return maker;
  }, maker);
  maker.frameInput = maker.frameInputs;
  maker.frameFile = maker.frameFiles;
  maker.frameImage = maker.frameImages;
}
5382
function useSlider(maker) {
  maker['sliderRange'] = creatorFactory('slider', {
    range: true
  });
}
5388
function useSelect(m) {
  m.selectMultiple = creatorFactory(name, {
    mode: 'multiple'
  });
  m.selectTags = creatorFactory(name, {
    mode: 'tags'
  });
  m.selectCombobox = creatorFactory(name, {
    mode: 'combobox'
  });
}
5400
function useUpload(maker) {
  var types = {
    image: ['image', 0],
    file: ['file', 0],
    uploadFileOne: ['file', 1],
    uploadImageOne: ['image', 1]
  };
  Object.keys(types).reduce(function (maker, key) {
    maker[key] = creatorFactory('upload', function (m) {
      return m.props({
        uploadType: types[key][0],
        maxLength: types[key][1]
      });
    });
    return maker;
  }, maker);
  maker.uploadImage = maker.image;
  maker.uploadFile = maker.file;
}
5420
useAlias(maker);
useSlider(maker);
useFrame(maker);
useUpload(maker);
useSelect(maker);
5426
var css_248z$1 = ".form-create .form-create .ant-form-item {\n    margin-bottom: 22px;\n}\n\n.form-create .form-create .ant-form-item .ant-form-item {\n    margin-bottom: 0px;\n}\n\n.form-create .form-create .ant-form-item.ant-form-item-with-help {\n    margin-bottom: 3px;\n}\n\n.form-create .form-create .ant-form-item .ant-form-item.ant-form-item-with-help {\n    margin-bottom: -22px;\n}\n\n.form-create{\n    transform: rotateZ(0);\n}\n";
styleInject(css_248z$1);
5429
function tidyBtnProp(btn, def) {
  if (is.Boolean(btn)) btn = {
    show: btn
  };else if (!is.Undef(btn) && !is.Object(btn)) btn = {
    show: def
  };
  return btn;
}
5438
function extendApi(api, h) {
  extend(api, {
    validate: function validate(callback) {
      var flag;
      var forms = api.children;
      var len = forms.length;
5445
      var validate = function validate() {
        h.$manager.validate(function () {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
5451
          if (!args[0] || !flag) {
            flag = args;
          }
5455
          callback && callback.apply(void 0, _toConsumableArray(flag));
        });
      };
5459
      var validFn = function validFn(args) {
        setTimeout(function () {
          if (!args[0]) {
            if (!flag) {
              flag = args;
            }
          }
5467
          if (! --len) {
            validate();
          }
        });
      };
5473
      forms.forEach(function (form) {
        form.validate(function () {
          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }
5479
          return validFn(args);
        });
      });
5483
      if (!len) {
        validate();
      }
    },
    validateField: function validateField(field, callback) {
      var ctx = h.getFieldCtx(field);
      if (!ctx) return;
      var sub = h.subForm[ctx.id];
      var len = 0;
      var flag;
5494
      var validate = function validate() {
        h.$manager.validateField(ctx.id, function () {
          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            args[_key3] = arguments[_key3];
          }
5500
          if (args[0]) {
            flag = args;
          } else if (flag) {
            return callback && callback('子表单验证未通过', flag[1]);
          }
5506
          callback && callback.apply(void 0, _toConsumableArray(flag || args));
        });
      };
5510
      var validFn = function validFn(args) {
        setTimeout(function () {
          if (!args[0]) {
            if (!flag) {
              flag = args;
            }
          }
5518
          if (! --len) {
            validate();
          }
        });
      };
5524
      sub && toArray(sub).forEach(function (form) {
        len++;
        form.validate(function () {
          for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
            args[_key4] = arguments[_key4];
          }
5531
          return validFn(args);
        });
      });
5535
      if (!len) {
        validate();
      }
    },
    clearValidateState: function clearValidateState(fields) {
      var _this = this;
5542
      var clearSub = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      api.helper.tidyFields(fields).forEach(function (field) {
        if (clearSub) _this.clearSubValidateState(field);
        h.getCtxs(field).forEach(function (ctx) {
          h.$manager.clearValidateState(ctx);
        });
      });
    },
    clearSubValidateState: function clearSubValidateState(fields) {
      api.helper.tidyFields(fields).forEach(function (field) {
        h.getCtxs(field).forEach(function (ctx) {
          var subForm = h.subForm[ctx.id];
          if (!subForm) return;
5556
          if (Array.isArray(subForm)) {
            subForm.forEach(function (form) {
              form.clearValidateState();
            });
          } else if (subForm) {
            subForm.clearValidateState();
          }
        });
      });
    },
    btn: {
      loading: function loading() {
        var _loading = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
5570
        api.submitBtnProps({
          loading: !!_loading
        });
      },
      disabled: function disabled() {
        var _disabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
5577
        api.submitBtnProps({
          disabled: !!_disabled
        });
      },
      show: function show() {
        var isShow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
        api.submitBtnProps({
          show: !!isShow
        });
      }
    },
    resetBtn: {
      loading: function loading() {
        var _loading2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
5592
        api.resetBtnProps({
          loading: !!_loading2
        });
      },
      disabled: function disabled() {
        var _disabled2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
5599
        api.resetBtnProps({
          disabled: !!_disabled2
        });
      },
      show: function show() {
        var isShow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
        api.resetBtnProps({
          show: !!isShow
        });
      }
    },
    submitBtnProps: function submitBtnProps() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var btn = tidyBtnProp(h.options.submitBtn, true);
      extend(btn, props);
      h.options.submitBtn = btn;
      api.refreshOptions();
    },
    resetBtnProps: function resetBtnProps() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var btn = tidyBtnProp(h.options.resetBtn, false);
      extend(btn, props);
      h.options.resetBtn = btn;
      api.refreshOptions();
    },
    submit: function submit(successFn, failFn) {
      var _arguments = arguments,
          _this2 = this;
5628
      api.validate(function (valid) {
        if (valid) {
          var formData = api.formData();
          if (is.Function(successFn)) invoke(function () {
            return successFn(formData, _this2);
          });else {
            is.Function(h.options.onSubmit) && invoke(function () {
              return h.options.onSubmit(formData, _this2);
            });
            h.vm.$emit('submit', formData, _this2);
          }
        } else {
          is.Function(failFn) && invoke(function () {
            return failFn.apply(void 0, [_this2].concat(_toConsumableArray(_arguments)));
          });
        }
      });
    }
  });
  return api;
}
5650
function install(FormCreate) {
  FormCreate.componentAlias(alias);
  components.forEach(function (component) {
    FormCreate.component(component.name, component);
  });
  parsers.forEach(function (parser) {
    FormCreate.parser(parser);
  });
  Object.keys(maker).forEach(function (name) {
    FormCreate.maker[name] = maker[name];
  });
}
5663
function antdvFormCreate() {
  return FormCreateFactory({
    ui: "".concat("ant-design-vue"),
    version: "".concat("2.5.11"),
    manager: manager,
    install: install,
    extendApi: extendApi,
    attrs: {
      normal: ['col', 'wrap'],
      array: ['className'],
      key: ['title', 'info']
    }
  });
}
5678
var FormCreate = antdvFormCreate();
5680
if (typeof window !== 'undefined') {
  window.formCreate = FormCreate;
5683
  if (window.Vue) {
    FormCreate.install(window.Vue);
  }
}
5688
var maker$1 = FormCreate.maker;
5690
exports.default = FormCreate;
exports.maker = maker$1;
5693
Object.defineProperty(exports, '__esModule', { value: true });
5695
5696})));
1	`/*!`
2	`* @form-create/ant-design-vue v2.5.11`
3	`* (c) 2018-2021 xaboy`
4	`* Github https://github.com/xaboy/form-create`
5	`* Released under the MIT License.`
6	`*/`
7	`(function (global, factory) {`
8	`typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('moment')) :`
9	`typeof define === 'function' && define.amd ? define(['exports', 'vue', 'moment'], factory) :`
10	`(global = global \|\| self, factory(global.formCreate = {}, global.Vue, global.moment));`
11	`}(this, (function (exports, Vue, moment) { 'use strict';`
12
13	`Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue;`
14	`moment = moment && Object.prototype.hasOwnProperty.call(moment, 'default') ? moment['default'] : moment;`
15
16	`function _extends() {`
17	`return _extends = Object.assign \|\| function (a) {`
18	`for (var b, c = 1; c < arguments.length; c++) {`
19	`for (var d in b = arguments[c], b) {`
20	`Object.prototype.hasOwnProperty.call(b, d) && (a[d] = b[d]);`
21	`}`
22	`}`
23
24	`return a;`
25	`}, _extends.apply(this, arguments);`
26	`}`
27
28	`var normalMerge = ["attrs", "props", "domProps"],`
29	`toArrayMerge = ["class", "style", "directives"],`
30	`functionalMerge = ["on", "nativeOn"],`
31	`mergeJsxProps = function mergeJsxProps(a) {`
32	`return a.reduce(function (c, a) {`
33	`for (var b in a) {`
34	`if (!c[b]) c[b] = a[b];else if (-1 !== normalMerge.indexOf(b)) c[b] = _extends({}, c[b], a[b]);else if (-1 !== toArrayMerge.indexOf(b)) {`
35	`var d = c[b] instanceof Array ? c[b] : [c[b]],`
36	`e = a[b] instanceof Array ? a[b] : [a[b]];`
37	`c[b] = d.concat(e);`
38	`} else if (-1 !== functionalMerge.indexOf(b)) {`
39	`for (var f in a[b]) {`
40	`if (c[b][f]) {`