@panpanzhao/component-ui 0.0.1

package/lib/components/table-editable.js

@@ -0,0 +1,954 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "/dist/";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 59);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = require("@vue/babel-helper-vue-jsx-merge-props");
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
+/* globals __VUE_SSR_CONTEXT__ */
+
+// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
+// This module is a runtime utility for cleaner component module output and will
+// be included in the final webpack user bundle.
+
+function normalizeComponent(
+  scriptExports,
+  render,
+  staticRenderFns,
+  functionalTemplate,
+  injectStyles,
+  scopeId,
+  moduleIdentifier /* server only */,
+  shadowMode /* vue-cli only */
+) {
+  // Vue.extend constructor export interop
+  var options =
+    typeof scriptExports === 'function' ? scriptExports.options : scriptExports
+
+  // render functions
+  if (render) {
+    options.render = render
+    options.staticRenderFns = staticRenderFns
+    options._compiled = true
+  }
+
+  // functional template
+  if (functionalTemplate) {
+    options.functional = true
+  }
+
+  // scopedId
+  if (scopeId) {
+    options._scopeId = 'data-v-' + scopeId
+  }
+
+  var hook
+  if (moduleIdentifier) {
+    // server build
+    hook = function (context) {
+      // 2.3 injection
+      context =
+        context || // cached call
+        (this.$vnode && this.$vnode.ssrContext) || // stateful
+        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
+      // 2.2 with runInNewContext: true
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+        context = __VUE_SSR_CONTEXT__
+      }
+      // inject component styles
+      if (injectStyles) {
+        injectStyles.call(this, context)
+      }
+      // register component module identifier for async chunk inferrence
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier)
+      }
+    }
+    // used by ssr in case component is cached and beforeCreate
+    // never gets called
+    options._ssrRegister = hook
+  } else if (injectStyles) {
+    hook = shadowMode
+      ? function () {
+          injectStyles.call(
+            this,
+            (options.functional ? this.parent : this).$root.$options.shadowRoot
+          )
+        }
+      : injectStyles
+  }
+
+  if (hook) {
+    if (options.functional) {
+      // for template-only hot-reload because in that case the render fn doesn't
+      // go through the normalizer
+      options._injectStyles = hook
+      // register for functional component in vue file
+      var originalRender = options.render
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context)
+        return originalRender(h, context)
+      }
+    } else {
+      // inject component registration as beforeCreate hook
+      var existing = options.beforeCreate
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]
+    }
+  }
+
+  return {
+    exports: scriptExports,
+    options: options
+  }
+}
+
+
+/***/ }),
+
+/***/ 21:
+/***/ (function(module, exports) {
+
+module.exports = require("component-ui/lib/components/form-input");
+
+/***/ }),
+
+/***/ 22:
+/***/ (function(module, exports) {
+
+module.exports = require("component-ui/lib/components/table-column");
+
+/***/ }),
+
+/***/ 24:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/table");
+
+/***/ }),
+
+/***/ 53:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/popover");
+
+/***/ }),
+
+/***/ 54:
+/***/ (function(module, exports) {
+
+module.exports = require("async-validator");
+
+/***/ }),
+
+/***/ 59:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--5!./node_modules/vue-loader/lib??vue-loader-options!./src/components/table-editable/src/index.vue?vue&type=template&id=1701e242&
+var srcvue_type_template_id_1701e242_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c
+  return _c(
+    "div",
+    { staticClass: "table-editable" },
+    [
+      _c(
+        "el-table",
+        _vm._g(
+          _vm._b({ ref: "table" }, "el-table", _vm.tableProps, false),
+          _vm.tableListeners
+        ),
+        [
+          _vm._l(_vm.columns, function (column) {
+            return [
+              _c(
+                "ColumnItem",
+                _vm._g(
+                  _vm._b(
+                    {
+                      key: `${column.control}_${column.prop}`,
+                      attrs: { actions: _vm.actionItem[column.prop] },
+                    },
+                    "ColumnItem",
+                    column,
+                    false
+                  ),
+                  column.on
+                )
+              ),
+            ]
+          }),
+        ],
+        2
+      ),
+    ],
+    1
+  )
+}
+var staticRenderFns = []
+srcvue_type_template_id_1701e242_render._withStripped = true
+
+
+// CONCATENATED MODULE: ./src/components/table-editable/src/index.vue?vue&type=template&id=1701e242&
+
+// EXTERNAL MODULE: external "element-ui/lib/table"
+var table_ = __webpack_require__(24);
+var table_default = /*#__PURE__*/__webpack_require__.n(table_);
+
+// EXTERNAL MODULE: external "@vue/babel-helper-vue-jsx-merge-props"
+var babel_helper_vue_jsx_merge_props_ = __webpack_require__(0);
+var babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(babel_helper_vue_jsx_merge_props_);
+
+// EXTERNAL MODULE: external "component-ui/lib/components/table-column"
+var table_column_ = __webpack_require__(22);
+var table_column_default = /*#__PURE__*/__webpack_require__.n(table_column_);
+
+// EXTERNAL MODULE: external "component-ui/lib/components/form-input"
+var form_input_ = __webpack_require__(21);
+var form_input_default = /*#__PURE__*/__webpack_require__.n(form_input_);
+
+// EXTERNAL MODULE: external "element-ui/lib/popover"
+var popover_ = __webpack_require__(53);
+var popover_default = /*#__PURE__*/__webpack_require__.n(popover_);
+
+// EXTERNAL MODULE: external "async-validator"
+var external_async_validator_ = __webpack_require__(54);
+var external_async_validator_default = /*#__PURE__*/__webpack_require__.n(external_async_validator_);
+
+// CONCATENATED MODULE: ./src/components/table-editable/src/form-item.js
+
+
+
+
+/* harmony default export */ var form_item = ({
+  name: "FormItem",
+  components: {
+    FormInput: form_input_default.a,
+    elPopover: popover_default.a
+  },
+  inheritAttrs: false,
+  props: {
+    prop: String,
+    label: String,
+    value: [String, Number, Boolean, Object, Array, Date],
+    rowData: Object,
+    row: Object,
+    actions: Array,
+    rules: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    on: Object,
+    slots: Object,
+    render: Function
+  },
+  data: function data() {
+    return {
+      inputConfig: null,
+      showMessage: false,
+      validateState: '',
+      validateMessage: '',
+      validateDisabled: false
+    };
+  },
+  computed: {
+    _tableEditable: function _tableEditable() {
+      var parent = this.$parent;
+      while (parent) {
+        if (parent.$options.componentName !== 'TableEditable') {
+          parent = parent.$parent;
+        } else {
+          return parent;
+        }
+      }
+      return false;
+    },
+    popoverShow: function popoverShow() {
+      if (this.showMessage && this.validateMessage) {
+        return true;
+      }
+      return false;
+    },
+    isRequired: function isRequired() {
+      var rules = this.rules;
+      var isRequired = false;
+      if (rules && rules.length) {
+        rules.every(function (rule) {
+          if (rule.required) {
+            isRequired = true;
+            return false;
+          }
+          return true;
+        });
+      }
+      return isRequired;
+    },
+    actionEventMap: function actionEventMap() {
+      var eventMap = {};
+      if (!this.actions) {
+        return eventMap;
+      }
+      this.actions.forEach(function (item) {
+        eventMap[item.event] = item;
+      });
+      return eventMap;
+    },
+    eventOn: function eventOn() {
+      var itemOn = {};
+      if (!this.$listeners) {
+        return itemOn;
+      }
+      var that = this;
+      Object.keys(this.$listeners).forEach(function (eventName) {
+        itemOn[eventName] = function () {
+          that.execEvent.apply(that, [eventName].concat(Array.prototype.slice.call(arguments)));
+        };
+      });
+      return itemOn;
+    },
+    actionEventOn: function actionEventOn() {
+      var relItemOn = {};
+      if (!this.actions) {
+        return relItemOn;
+      }
+      // 联动函数执行
+      var that = this;
+      this.actions.forEach(function (item) {
+        relItemOn[item.event] = function () {
+          that.execEvent.apply(that, [item.event].concat(Array.prototype.slice.call(arguments)));
+        };
+      });
+      return relItemOn;
+    }
+  },
+  created: function created() {
+    this.inputConfig = Object.assign({
+      prop: this.prop,
+      label: this.label,
+      rules: this.rules
+    }, this.$attrs);
+  },
+  mounted: function mounted() {
+    if (this.prop) {
+      this.dispatch("TableEditable", "addField", [this]);
+    }
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.dispatch("TableEditable", "removeField", [this]);
+  },
+  methods: {
+    execEvent: function execEvent(eventName) {
+      var _itemEvent$exec;
+      for (var _len = arguments.length, arg = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        arg[_key - 1] = arguments[_key];
+      }
+      //默认事件
+      if (this.$listeners && this.$listeners[eventName]) {
+        this.$emit.apply(this, [eventName, {
+          trigger: this.row,
+          triggerForm: this.rowData,
+          triggerConfig: this.inputConfig
+        }].concat(arg));
+      }
+      //联动配置事件
+      var itemEvent = this.actionEventMap[eventName];
+      if (!itemEvent) {
+        return false;
+      }
+      var targetConfig = {};
+      var fieldMap = this._tableEditable.getRowField(this.row);
+      if (Array.isArray(itemEvent.target)) {
+        itemEvent.target.forEach(function (tarItem) {
+          targetConfig[tarItem] = fieldMap[tarItem] && fieldMap[tarItem].inputConfig;
+        });
+      } else if (typeof itemEvent.target === "string") {
+        targetConfig[itemEvent.target] = fieldMap[itemEvent.target] && fieldMap[itemEvent.target].inputConfig;
+      }
+      (_itemEvent$exec = itemEvent.exec).call.apply(_itemEvent$exec, [this, {
+        trigger: this.row,
+        triggerForm: this.rowData,
+        triggerConfig: this.inputConfig,
+        targetConfig: targetConfig
+      }].concat(arg));
+    },
+    dispatch: function dispatch(componentName, eventName, params) {
+      var parent = this.$parent || this.$root;
+      var name = parent.$options.componentName;
+      while (parent && (!name || name !== componentName)) {
+        parent = parent.$parent;
+        if (parent) {
+          name = parent.$options.componentName;
+        }
+      }
+      if (parent) {
+        parent.$emit.apply(parent, [eventName].concat(params));
+      }
+    },
+    validate: function validate(trigger, callback) {
+      var _this = this;
+      if (callback === void 0) {
+        callback = function noop() {};
+      }
+      this.validateDisabled = false;
+      var rules = this.getFilteredRule(trigger);
+      if (!rules || rules.length === 0) {
+        callback();
+        return true;
+      }
+      this.validateState = 'validating';
+      var descriptor = {};
+      if (rules && rules.length > 0) {
+        rules.forEach(function (rule) {
+          delete rule.trigger;
+        });
+      }
+      descriptor[this.prop] = rules;
+      var validator = new external_async_validator_default.a(descriptor);
+      var model = {};
+      model[this.prop] = this.rowData[this.prop];
+      validator.validate(model, {
+        firstFields: true
+      }, function (errors, invalidFields) {
+        _this.validateState = !errors ? 'success' : 'error';
+        _this.validateMessage = errors ? errors[0].message : '';
+        callback(_this.validateMessage, invalidFields);
+      });
+    },
+    clearValidate: function clearValidate() {
+      this.validateState = "";
+      this.validateMessage = "";
+      this.validateDisabled = false;
+    },
+    onFieldBlur: function onFieldBlur() {
+      this.validate('blur');
+    },
+    onFieldInput: function onFieldInput() {
+      if (this.validateDisabled) {
+        this.validateDisabled = false;
+        return;
+      }
+      this.validate('input');
+    },
+    onFieldChange: function onFieldChange() {
+      if (this.validateDisabled) {
+        this.validateDisabled = false;
+        return;
+      }
+      this.validate('change');
+    },
+    getFilteredRule: function getFilteredRule(trigger) {
+      var rules = this.rules;
+      return rules.filter(function (rule) {
+        if (!rule.trigger || trigger === '') return true;
+        if (Array.isArray(rule.trigger)) {
+          return rule.trigger.indexOf(trigger) > -1;
+        } else {
+          return rule.trigger === trigger;
+        }
+      }).map(function (rule) {
+        return Object.assign({}, rule);
+      });
+    }
+  },
+  render: function render(h) {
+    var _this2 = this;
+    var param = {
+      attrs: Object.assign({}, this.inputConfig, {
+        value: this.value
+      }),
+      on: Object.assign({}, this.eventOn, this.actionEventOn, {
+        focus: function focus() {
+          _this2.execEvent("focus");
+          _this2.showMessage = true;
+        },
+        blur: function blur() {
+          _this2.execEvent("blur");
+          _this2.showMessage = false;
+          _this2.onFieldBlur();
+        },
+        input: function input(val) {
+          _this2.execEvent("input", val);
+          _this2.rowData[_this2.prop] = val;
+          _this2.onFieldInput();
+        },
+        change: function change(val, selectOption) {
+          _this2.execEvent("change", val, selectOption);
+          _this2.rowData[_this2.prop] = val;
+          _this2.onFieldChange();
+        }
+      }),
+      slots: this.slots,
+      scopedSlots: this.slots
+    };
+    return h("div", {
+      "class": ["column-form-item", {
+        "is-required": this.isRequired,
+        'is-error': this.validateState === 'error',
+        'is-validating': this.validateState === 'validating',
+        'is-success': this.validateState === 'success'
+      }]
+    }, [h("el-popover", {
+      "attrs": {
+        "popper-class": "popover-error",
+        "trigger": "manual",
+        "placement": "top-start",
+        "content": this.validateMessage,
+        "value": this.popoverShow
+      }
+    }, [h("div", {
+      "slot": "reference"
+    }, [h(form_input_default.a, babel_helper_vue_jsx_merge_props_default()([{}, param]))])])]);
+  }
+});
+// CONCATENATED MODULE: ./src/components/table-editable/src/column-item.js
+
+
+
+
+/* harmony default export */ var column_item = ({
+  name: "ColumnItem",
+  components: {
+    TableColumn: table_column_default.a,
+    FormItem: form_item
+  },
+  inheritAttrs: false,
+  props: {
+    prop: String,
+    label: String,
+    value: [String, Number, Boolean, Object, Array, Date],
+    config: Object,
+    actions: Array,
+    on: Object,
+    render: Function
+  },
+  data: function data() {
+    return {};
+  },
+  methods: {
+    renderFormInput: function renderFormInput(h, scoped) {
+      var rowData = scoped.row;
+      var param = {
+        attrs: Object.assign({
+          prop: this.prop,
+          label: this.label,
+          actions: this.actions
+        }, this.config, {
+          value: rowData[this.prop],
+          rowData: rowData,
+          row: scoped
+        }),
+        on: Object.assign({}, this.$listeners),
+        slots: this.config.slots,
+        scopedSlots: this.config.slots
+      };
+      return h(form_item, babel_helper_vue_jsx_merge_props_default()([{}, param]));
+    }
+  },
+  render: function render(h) {
+    var _this = this;
+    var param = {
+      attrs: Object.assign({
+        prop: this.prop,
+        label: this.label
+      }, this.$attrs),
+      on: Object.assign({}, this.$listeners),
+      slots: this.$slots,
+      scopedSlots: this.$scopedSlots
+    };
+    if (this.config) {
+      param.scopedSlots["default"] = function (scoped) {
+        return _this.renderFormInput(h, scoped);
+      };
+    }
+    return h(table_column_default.a, babel_helper_vue_jsx_merge_props_default()([{}, param]));
+  }
+});
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./src/components/table-editable/src/index.vue?vue&type=script&lang=js&
+
+
+/* harmony default export */ var srcvue_type_script_lang_js_ = ({
+  name: "TableEditable",
+  componentName: "TableEditable",
+  components: {
+    elTable: table_default.a,
+    ColumnItem: column_item
+  },
+  provide: function provide() {
+    return {
+      table: this
+    };
+  },
+  props: {
+    rowKey: {
+      type: String,
+      default: function _default() {
+        return "id";
+      }
+    },
+    data: {
+      type: Array,
+      default: function _default() {
+        return null;
+      }
+    },
+    columns: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    actions: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    on: {
+      type: Object,
+      default: function _default() {
+        return {};
+      }
+    },
+    slots: {
+      type: Object,
+      default: function _default() {
+        return {};
+      }
+    }
+  },
+  data: function data() {
+    return {
+      rowId: null,
+      selection: [],
+      fields: []
+    };
+  },
+  computed: {
+    request: function request() {
+      return this.api.request || (this.$COMPONENT || {}).request;
+    },
+    tableProps: function tableProps() {
+      return Object.assign({
+        highlightCurrentRow: true,
+        stripe: true,
+        defaultExpandAll: true,
+        size: "mini"
+      }, this.$attrs, {
+        rowKey: this.rowKey,
+        data: this.data
+      });
+    },
+    tableListeners: function tableListeners() {
+      var _this = this;
+      return Object.assign({}, this.$listeners, {
+        "row-click": function rowClick(row) {
+          var selectColumns = _this.columns.filter(function (item) {
+            return item.control === "Selection";
+          });
+          if (selectColumns && selectColumns.length > 0) {
+            var selectColumn = selectColumns[0];
+            if (selectColumn.type === "radio") {
+              var key = selectColumn.prop || _this.tableProps.rowKey;
+              _this.rowId = row[key];
+              _this.selection = [row];
+            } else {
+              _this.$refs.table.toggleRowSelection(row); // 点击选中
+            }
+          }
+
+          _this.$emit("row-click", row);
+        },
+        "selection-change": function selectionChange(selection) {
+          _this.selection = selection;
+          _this.$emit("selection-change", selection);
+        }
+      });
+    },
+    rowData: function rowData() {
+      var rowData = {};
+      this.columns.forEach(function (column) {
+        if (column.prop) {
+          rowData[column.prop] = column.config && column.config.value;
+        }
+      });
+      return rowData;
+    },
+    actionItem: function actionItem() {
+      var relItem = {};
+      this.actions.forEach(function (item) {
+        if (!relItem[item.trigger]) {
+          relItem[item.trigger] = [];
+        }
+        relItem[item.trigger].push(item);
+      });
+      return relItem;
+    }
+  },
+  created: function created() {
+    var _this2 = this;
+    this.$on("addField", function (field) {
+      if (field) {
+        _this2.fields.push(field);
+      }
+    });
+    /* istanbul ignore next */
+    this.$on("removeField", function (field) {
+      if (field) {
+        _this2.fields.splice(_this2.fields.indexOf(field), 1);
+      }
+    });
+  },
+  methods: {
+    validate: function validate(callback) {
+      var _this3 = this;
+      var promise;
+      // if no callback, return promise
+      if (typeof callback !== 'function' && window.Promise) {
+        promise = new window.Promise(function (resolve, reject) {
+          callback = function callback(valid, invalidFields) {
+            valid ? resolve(valid) : reject(invalidFields);
+          };
+        });
+      }
+      var valid = true;
+      var count = 0;
+      // 如果需要验证的fields为空，调用验证时立刻返回callback
+      if (this.fields.length === 0 && callback) {
+        callback(true);
+      }
+      var invalidFields = [];
+      this.fields.forEach(function (field) {
+        field.validate('', function (message, fieldMsg) {
+          if (message) {
+            valid = false;
+          }
+          var rowIndex = field.row && field.row.$index;
+          if (!invalidFields[rowIndex]) {
+            invalidFields[rowIndex] = {};
+          }
+          Object.assign(invalidFields[rowIndex], fieldMsg);
+          if (typeof callback === 'function' && ++count === _this3.fields.length) {
+            callback(valid, invalidFields);
+          }
+        });
+      });
+      if (promise) {
+        return promise;
+      }
+    },
+    validateRow: function validateRow(rowIndex, callback) {
+      var promise;
+      // if no callback, return promise
+      if (typeof callback !== 'function' && window.Promise) {
+        promise = new window.Promise(function (resolve, reject) {
+          callback = function callback(valid, invalidFields) {
+            valid ? resolve(valid) : reject(invalidFields);
+          };
+        });
+      }
+      var valid = true;
+      var count = 0;
+      // 如果需要验证的fields为空，调用验证时立刻返回callback
+      var fields = this.fields.filter(function (item) {
+        return item.row && item.row.$index === rowIndex;
+      });
+      if (fields.length === 0 && callback) {
+        callback(true);
+      }
+      var invalidFields = {};
+      fields.forEach(function (field) {
+        field.validate('', function (message, fieldMsg) {
+          if (message) {
+            valid = false;
+          }
+          Object.assign(invalidFields, fieldMsg);
+          if (typeof callback === 'function' && ++count === fields.length) {
+            callback(valid, invalidFields);
+          }
+        });
+      });
+      if (promise) {
+        return promise;
+      }
+    },
+    validateField: function validateField(rowIndex, props, cb) {
+      props = [].concat(props);
+      var fields = this.fields.filter(function (item) {
+        return item.row && item.row.$index === rowIndex && props.indexOf(item.prop) !== -1;
+      });
+      if (!fields.length) {
+        console.warn('[Element Warn]please pass correct props!');
+        return;
+      }
+      fields.forEach(function (field) {
+        field.validate('', cb);
+      });
+    },
+    clearValidate: function clearValidate(rowIndex, props) {
+      if (props === void 0) {
+        props = [];
+      }
+      var fields = this.fields;
+      if (typeof rowIndex === "number") {
+        fields = props.length ? this.fields.filter(function (item) {
+          return item.row && item.row.$index === rowIndex && props.indexOf(item.prop) !== -1;
+        }) : this.fields.filter(function (item) {
+          return item.row && item.row.$index === rowIndex;
+        });
+      }
+      fields.forEach(function (field) {
+        field.clearValidate();
+      });
+    },
+    getRowField: function getRowField(row) {
+      var fieldMap = {};
+      var fields = this.fields.filter(function (item) {
+        return item.row && item.row.$index === row.$index;
+      });
+      fields.forEach(function (item) {
+        fieldMap[item.prop] = item;
+      });
+      return fieldMap;
+    },
+    addRow: function addRow(data) {
+      this.data.push(Object.assign({}, this.rowData, data));
+    },
+    deleteRow: function deleteRow(index) {
+      this.data && this.data.splice(index, 1);
+    }
+  }
+});
+// CONCATENATED MODULE: ./src/components/table-editable/src/index.vue?vue&type=script&lang=js&
+ /* harmony default export */ var table_editable_srcvue_type_script_lang_js_ = (srcvue_type_script_lang_js_); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./src/components/table-editable/src/index.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  table_editable_srcvue_type_script_lang_js_,
+  srcvue_type_template_id_1701e242_render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var src = (component.exports);
+// CONCATENATED MODULE: ./src/components/table-editable/index.js
+
+src.install = function (Vue) {
+  Vue.component(src.name, src);
+};
+/* harmony default export */ var table_editable = __webpack_exports__["default"] = (src);
+
+/***/ })
+
+/******/ });