vxe-table 3.19.39 → 3.20.0-beta.1

package/lib/table/module/validator/mixin.js

@@ -151,253 +151,252 @@ function checkRuleStatus(rule, val) {
   }
   return true;
 }
+/**
+ * 聚焦到校验通过的单元格并弹出校验错误提示
+ */
+function handleValidError($xeTable, params) {
+  return new Promise(resolve => {
+    const validOpts = $xeTable.computeValidOpts;
+    if (validOpts.autoPos === false) {
+      $xeTable.dispatchEvent('valid-error', params, null);
+      resolve();
+    } else {
+      $xeTable.handleEdit(params, {
+        type: 'valid-error',
+        trigger: 'call'
+      }).then(() => {
+        setTimeout(() => {
+          resolve($xeTable.showValidTooltip(params));
+        }, 10);
+      });
+    }
+  });
+}
+function handleErrMsgMode($xeTable, validErrMaps) {
+  const validOpts = $xeTable.computeValidOpts;
+  if (validOpts.msgMode === 'single') {
+    const keys = Object.keys(validErrMaps);
+    const resMaps = {};
+    if (keys.length) {
+      const firstKey = keys[0];
+      resMaps[firstKey] = validErrMaps[firstKey];
+    }
+    return resMaps;
+  }
+  return validErrMaps;
+}
+/**
+ * 对表格数据进行校验
+ * 如果不指定数据，则默认只校验临时变动的数据，例如新增或修改
+ * 如果传 true 则校验当前表格数据
+ * 如果传 row 指定行记录，则只验证传入的行
+ * 如果传 rows 为多行记录，则只验证传入的行
+ * 如果只传 callback 否则默认验证整个表格数据
+ * 返回 Promise 对象，或者使用回调方式
+ */
+function beginValidate($xeTable, rows, cols, cb, isFull) {
+  const props = $xeTable;
+  const reactData = $xeTable;
+  const internalData = $xeTable;
+  const validRest = {};
+  const {
+    editRules,
+    treeConfig
+  } = props;
+  const {
+    isRowGroupStatus
+  } = reactData;
+  const {
+    afterFullData,
+    pendingRowMaps,
+    removeRowMaps
+  } = internalData;
+  const treeOpts = $xeTable.computeTreeOpts;
+  const aggregateOpts = $xeTable.computeAggregateOpts;
+  const validOpts = $xeTable.computeValidOpts;
+  let validList;
+  if (rows === true) {
+    validList = afterFullData;
+  } else if (rows) {
+    if (_xeUtils.default.isFunction(rows)) {
+      cb = rows;
+    } else {
+      validList = _xeUtils.default.isArray(rows) ? rows : [rows];
+    }
+  }
+  if (!validList) {
+    validList = $xeTable.getInsertRecords().concat($xeTable.getUpdateRecords());
+  }
+  const rowValidErrs = [];
+  internalData._lastCallTime = Date.now();
+  internalData.validRuleErr = false; // 如果为快速校验，当存在某列校验不通过时将终止执行
+  $xeTable.clearValidate();
+  const validErrMaps = {};
+  if (editRules) {
+    const columns = cols && cols.length ? cols : $xeTable.getColumns();
+    const handleVaild = row => {
+      const rowid = (0, _util.getRowid)($xeTable, row);
+      // 是否删除
+      if (removeRowMaps[rowid]) {
+        return;
+      }
+      // 是否标记删除
+      if (pendingRowMaps[rowid]) {
+        return;
+      }
+      if ($xeTable.isAggregateRecord(row)) {
+        return;
+      }
+      if (isFull || !internalData.validRuleErr) {
+        const colVailds = [];
+        columns.forEach(column => {
+          const field = _xeUtils.default.isString(column) ? column : column.field;
+          if ((isFull || !internalData.validRuleErr) && _xeUtils.default.has(editRules, field)) {
+            colVailds.push($xeTable.validCellRules('all', row, column).catch(({
+              rule,
+              rules
+            }) => {
+              const rest = {
+                rule,
+                rules,
+                rowIndex: $xeTable.getRowIndex(row),
+                row,
+                columnIndex: $xeTable.getColumnIndex(column),
+                column,
+                field,
+                $table: $xeTable
+              };
+              if (!validRest[field]) {
+                validRest[field] = [];
+              }
+              validErrMaps[`${(0, _util.getRowid)($xeTable, row)}:${column.id}`] = {
+                column,
+                row,
+                rule,
+                content: rule.content
+              };
+              validRest[field].push(rest);
+              if (!isFull) {
+                internalData.validRuleErr = true;
+                return Promise.reject(rest);
+              }
+            }));
+          }
+        });
+        rowValidErrs.push(Promise.all(colVailds));
+      }
+    };
+    if (isRowGroupStatus) {
+      _xeUtils.default.eachTree(validList, handleVaild, {
+        children: aggregateOpts.mapChildrenField
+      });
+    } else if (treeConfig) {
+      const childrenField = treeOpts.children || treeOpts.childrenField;
+      _xeUtils.default.eachTree(validList, handleVaild, {
+        children: childrenField
+      });
+    } else {
+      validList.forEach(handleVaild);
+    }
+    return Promise.all(rowValidErrs).then(() => {
+      const ruleProps = Object.keys(validRest);
+      reactData.validErrorMaps = handleErrMsgMode($xeTable, validErrMaps);
+      return $xeTable.$nextTick().then(() => {
+        if (ruleProps.length) {
+          return Promise.reject(validRest[ruleProps[0]][0]);
+        }
+        if (cb) {
+          cb();
+        }
+      });
+    }).catch(firstErrParams => {
+      return new Promise((resolve, reject) => {
+        const finish = () => {
+          $xeTable.$nextTick(() => {
+            if (cb) {
+              cb(validRest);
+              resolve();
+            } else {
+              if (getConfig().validToReject === 'obsolete') {
+                // 已废弃，校验失败将不会执行catch
+                reject(validRest);
+              } else {
+                resolve(validRest);
+              }
+            }
+          });
+        };
+        const posAndFinish = () => {
+          firstErrParams.cell = $xeTable.getCellElement(firstErrParams.row, firstErrParams.column);
+          (0, _dom.scrollToView)(firstErrParams.cell);
+          handleValidError($xeTable, firstErrParams).then(finish);
+        };
+        /**
+         * 当校验不通过时
+         * 将表格滚动到可视区
+         * 由于提示信息至少需要占一行，定位向上偏移一行
+         */
+        if (validOpts.autoPos === false) {
+          finish();
+        } else {
+          const row = firstErrParams.row;
+          const column = firstErrParams.column;
+          $xeTable.scrollToRow(row, column).then(posAndFinish);
+        }
+      });
+    });
+  } else {
+    reactData.validErrorMaps = {};
+  }
+  return $xeTable.$nextTick().then(() => {
+    if (cb) {
+      cb();
+    }
+  });
+}
 var _default = exports.default = {
   methods: {
     /**
      * 完整校验，和 validate 的区别就是会给有效数据中的每一行进行校验
      */
     _fullValidate(rows, cb) {
+      const $xeTable = this;
       if (_xeUtils.default.isFunction(cb)) {
         (0, _log.warnLog)('vxe.error.notValidators', ['fullValidate(rows, callback)', 'fullValidate(rows)']);
       }
-      return this.beginValidate(rows, null, cb, true);
+      return beginValidate($xeTable, rows, null, cb, true);
     },
     /**
      * 快速校验，如果存在记录不通过的记录，则返回不再继续校验（异步校验除外）
      */
     _validate(rows, cb) {
+      const $xeTable = this;
       if (_xeUtils.default.isFunction(cb)) {
         (0, _log.warnLog)('vxe.error.notValidators', ['validate(rows, callback)', 'validate(rows)']);
       }
-      return this.beginValidate(rows, null, cb);
+      return beginValidate($xeTable, rows, null, cb);
     },
     /**
      * 完整校验单元格，和 validateField 的区别就是会给有效数据中的每一行进行校验
      */
     _fullValidateField(rows, fieldOrColumn) {
+      const $xeTable = this;
       const colList = (_xeUtils.default.isArray(fieldOrColumn) ? fieldOrColumn : fieldOrColumn ? [fieldOrColumn] : []).map(column => (0, _util.handleFieldOrColumn)(this, column));
       if (colList.length) {
-        return this.beginValidate(rows, colList, null, true);
+        return beginValidate($xeTable, rows, colList, null, true);
       }
-      return this.$nextTick();
+      return $xeTable.$nextTick();
     },
     /**
      * 快速校验单元格，如果存在记录不通过的记录，则返回不再继续校验（异步校验除外）
      */
     _validateField(rows, fieldOrColumn) {
+      const $xeTable = this;
       const colList = (_xeUtils.default.isArray(fieldOrColumn) ? fieldOrColumn : fieldOrColumn ? [fieldOrColumn] : []).map(column => (0, _util.handleFieldOrColumn)(this, column));
       if (colList.length) {
-        return this.beginValidate(rows, colList, null);
+        return beginValidate($xeTable, rows, colList, null);
       }
-      return this.$nextTick();
-    },
-    /**
-     * 聚焦到校验通过的单元格并弹出校验错误提示
-     */
-    handleValidError(params) {
-      const $xeTable = this;
-      const {
-        validOpts
-      } = this;
-      return new Promise(resolve => {
-        if (validOpts.autoPos === false) {
-          $xeTable.dispatchEvent('valid-error', params, null);
-          resolve();
-        } else {
-          this.handleEdit(params, {
-            type: 'valid-error',
-            trigger: 'call'
-          }).then(() => {
-            setTimeout(() => {
-              resolve(this.showValidTooltip(params));
-            }, 10);
-          });
-        }
-      });
-    },
-    handleErrMsgMode(validErrMaps) {
-      const {
-        validOpts
-      } = this;
-      if (validOpts.msgMode === 'single') {
-        const keys = Object.keys(validErrMaps);
-        const resMaps = {};
-        if (keys.length) {
-          const firstKey = keys[0];
-          resMaps[firstKey] = validErrMaps[firstKey];
-        }
-        return resMaps;
-      }
-      return validErrMaps;
-    },
-    /**
-     * 对表格数据进行校验
-     * 如果不指定数据，则默认只校验临时变动的数据，例如新增或修改
-     * 如果传 true 则校验当前表格数据
-     * 如果传 row 指定行记录，则只验证传入的行
-     * 如果传 rows 为多行记录，则只验证传入的行
-     * 如果只传 callback 否则默认验证整个表格数据
-     * 返回 Promise 对象，或者使用回调方式
-     */
-    beginValidate(rows, cols, cb, isFull) {
-      const $xeTable = this;
-      const props = $xeTable;
-      const reactData = $xeTable;
-      const internalData = $xeTable;
-      const validRest = {};
-      const {
-        editRules,
-        treeConfig
-      } = props;
-      const {
-        isRowGroupStatus
-      } = reactData;
-      const {
-        afterFullData,
-        pendingRowMaps,
-        removeRowMaps
-      } = internalData;
-      const treeOpts = $xeTable.computeTreeOpts;
-      const aggregateOpts = $xeTable.computeAggregateOpts;
-      let validList;
-      if (rows === true) {
-        validList = afterFullData;
-      } else if (rows) {
-        if (_xeUtils.default.isFunction(rows)) {
-          cb = rows;
-        } else {
-          validList = _xeUtils.default.isArray(rows) ? rows : [rows];
-        }
-      }
-      if (!validList) {
-        validList = this.getInsertRecords().concat(this.getUpdateRecords());
-      }
-      const rowValidErrs = [];
-      this.lastCallTime = Date.now();
-      this.validRuleErr = false; // 如果为快速校验，当存在某列校验不通过时将终止执行
-      this.clearValidate();
-      const validErrMaps = {};
-      if (editRules) {
-        const columns = cols && cols.length ? cols : this.getColumns();
-        const handleVaild = row => {
-          const rowid = (0, _util.getRowid)($xeTable, row);
-          // 是否删除
-          if (removeRowMaps[rowid]) {
-            return;
-          }
-          // 是否标记删除
-          if (pendingRowMaps[rowid]) {
-            return;
-          }
-          if ($xeTable.isAggregateRecord(row)) {
-            return;
-          }
-          if (isFull || !this.validRuleErr) {
-            const colVailds = [];
-            columns.forEach(column => {
-              const field = _xeUtils.default.isString(column) ? column : column.field;
-              if ((isFull || !this.validRuleErr) && _xeUtils.default.has(editRules, field)) {
-                colVailds.push(this.validCellRules('all', row, column).catch(({
-                  rule,
-                  rules
-                }) => {
-                  const rest = {
-                    rule,
-                    rules,
-                    rowIndex: this.getRowIndex(row),
-                    row,
-                    columnIndex: this.getColumnIndex(column),
-                    column,
-                    field,
-                    $table: this
-                  };
-                  if (!validRest[field]) {
-                    validRest[field] = [];
-                  }
-                  validErrMaps[`${(0, _util.getRowid)(this, row)}:${column.id}`] = {
-                    column,
-                    row,
-                    rule,
-                    content: rule.content
-                  };
-                  validRest[field].push(rest);
-                  if (!isFull) {
-                    this.validRuleErr = true;
-                    return Promise.reject(rest);
-                  }
-                }));
-              }
-            });
-            rowValidErrs.push(Promise.all(colVailds));
-          }
-        };
-        if (isRowGroupStatus) {
-          _xeUtils.default.eachTree(validList, handleVaild, {
-            children: aggregateOpts.mapChildrenField
-          });
-        } else if (treeConfig) {
-          const childrenField = treeOpts.children || treeOpts.childrenField;
-          _xeUtils.default.eachTree(validList, handleVaild, {
-            children: childrenField
-          });
-        } else {
-          validList.forEach(handleVaild);
-        }
-        return Promise.all(rowValidErrs).then(() => {
-          const ruleProps = Object.keys(validRest);
-          this.validErrorMaps = this.handleErrMsgMode(validErrMaps);
-          return this.$nextTick().then(() => {
-            if (ruleProps.length) {
-              return Promise.reject(validRest[ruleProps[0]][0]);
-            }
-            if (cb) {
-              cb();
-            }
-          });
-        }).catch(firstErrParams => {
-          return new Promise((resolve, reject) => {
-            const finish = () => {
-              this.$nextTick(() => {
-                if (cb) {
-                  cb(validRest);
-                  resolve();
-                } else {
-                  if (getConfig().validToReject === 'obsolete') {
-                    // 已废弃，校验失败将不会执行catch
-                    reject(validRest);
-                  } else {
-                    resolve(validRest);
-                  }
-                }
-              });
-            };
-            const posAndFinish = () => {
-              firstErrParams.cell = this.getCellElement(firstErrParams.row, firstErrParams.column);
-              (0, _dom.scrollToView)(firstErrParams.cell);
-              this.handleValidError(firstErrParams).then(finish);
-            };
-            /**
-             * 当校验不通过时
-             * 将表格滚动到可视区
-             * 由于提示信息至少需要占一行，定位向上偏移一行
-             */
-            if (this.validOpts.autoPos === false) {
-              finish();
-            } else {
-              const row = firstErrParams.row;
-              const column = firstErrParams.column;
-              this.scrollToRow(row, column).then(posAndFinish);
-            }
-          });
-        });
-      } else {
-        this.validErrorMaps = {};
-      }
-      return this.$nextTick().then(() => {
-        if (cb) {
-          cb();
-        }
-      });
+      return $xeTable.$nextTick();
     },
     hasCellRules(type, row, column) {
       const {
@@ -427,18 +426,21 @@ var _default = exports.default = {
      *  trigger=blur|change 触发方式（除非特殊场景，否则默认为空就行）
      */
     validCellRules(validType, row, column, val) {
+      const $xeTable = this;
+      const props = $xeTable;
+      const internalData = $xeTable;
       const {
         editRules
-      } = this;
+      } = props;
       const {
-        property
+        field
       } = column;
       const errorRules = [];
       const syncValidList = [];
-      if (property && editRules) {
-        const rules = _xeUtils.default.get(editRules, property);
+      if (field && editRules) {
+        const rules = _xeUtils.default.get(editRules, field);
         if (rules) {
-          const cellValue = _xeUtils.default.isUndefined(val) ? _xeUtils.default.get(row, property) : val;
+          const cellValue = _xeUtils.default.isUndefined(val) ? _xeUtils.default.get(row, field) : val;
           rules.forEach(rule => {
             const {
               trigger,
@@ -451,11 +453,11 @@ var _default = exports.default = {
                   rule,
                   rules,
                   row,
-                  rowIndex: this.getRowIndex(row),
+                  rowIndex: $xeTable.getRowIndex(row),
                   column,
-                  columnIndex: this.getColumnIndex(column),
-                  field: column.property,
-                  $table: this
+                  columnIndex: $xeTable.getColumnIndex(column),
+                  field: column.field,
+                  $table: $xeTable
                 };
                 let customValid;
                 if (_xeUtils.default.isString(validator)) {
@@ -475,7 +477,7 @@ var _default = exports.default = {
                 }
                 if (customValid) {
                   if (_xeUtils.default.isError(customValid)) {
-                    this.validRuleErr = true;
+                    internalData.validRuleErr = true;
                     errorRules.push(new Rule({
                       type: 'custom',
                       trigger,
@@ -485,7 +487,7 @@ var _default = exports.default = {
                   } else if (customValid.catch) {
                     // 如果为异步校验（注：异步校验是并发无序的）
                     syncValidList.push(customValid.catch(e => {
-                      this.validRuleErr = true;
+                      internalData.validRuleErr = true;
                       errorRules.push(new Rule({
                         type: 'custom',
                         trigger,
@@ -497,7 +499,7 @@ var _default = exports.default = {
                 }
               } else {
                 if (!checkRuleStatus(rule, cellValue)) {
-                  this.validRuleErr = true;
+                  internalData.validRuleErr = true;
                   errorRules.push(new Rule(rule));
                 }
               }
@@ -516,34 +518,36 @@ var _default = exports.default = {
       });
     },
     _clearValidate(rows, fieldOrColumn) {
+      const $xeTable = this;
+      const reactData = $xeTable;
       const {
-        validOpts,
         validErrorMaps
-      } = this;
-      const validTip = this.$refs.refValidTooltip;
+      } = reactData;
+      const validTip = $xeTable.$refs.refValidTooltip;
+      const validOpts = $xeTable.computeValidOpts;
       const rowList = _xeUtils.default.isArray(rows) ? rows : rows ? [rows] : [];
-      const colList = (_xeUtils.default.isArray(fieldOrColumn) ? fieldOrColumn : fieldOrColumn ? [fieldOrColumn] : []).map(column => (0, _util.handleFieldOrColumn)(this, column));
+      const colList = (_xeUtils.default.isArray(fieldOrColumn) ? fieldOrColumn : fieldOrColumn ? [fieldOrColumn] : []).map(column => (0, _util.handleFieldOrColumn)($xeTable, column));
       let validErrMaps = {};
-      if (validTip && validTip.visible) {
+      if (validTip && validTip.reactData.visible) {
         validTip.close();
       }
       // 如果是单个提示模式
       if (validOpts.msgMode === 'single') {
-        this.validErrorMaps = {};
-        return this.$nextTick();
+        reactData.validErrorMaps = {};
+        return $xeTable.$nextTick();
       }
       if (rowList.length && colList.length) {
         validErrMaps = Object.assign({}, validErrorMaps);
         rowList.forEach(row => {
           colList.forEach(column => {
-            const validKey = `${(0, _util.getRowid)(this, row)}:${column.id}`;
+            const validKey = `${(0, _util.getRowid)($xeTable, row)}:${column.id}`;
             if (validErrMaps[validKey]) {
               delete validErrMaps[validKey];
             }
           });
         });
       } else if (rowList.length) {
-        const rowIdList = rowList.map(row => `${(0, _util.getRowid)(this, row)}`);
+        const rowIdList = rowList.map(row => `${(0, _util.getRowid)($xeTable, row)}`);
         _xeUtils.default.each(validErrorMaps, (item, key) => {
           if (rowIdList.indexOf(key.split(':')[0]) > -1) {
             validErrMaps[key] = item;
@@ -557,26 +561,31 @@ var _default = exports.default = {
           }
         });
       }
-      this.validErrorMaps = validErrMaps;
-      return this.$nextTick();
+      reactData.validErrorMaps = validErrMaps;
+      return $xeTable.$nextTick();
     },
     /**
      * 触发校验
      */
     triggerValidate(type) {
+      const $xeTable = this;
+      const props = $xeTable;
+      const reactData = $xeTable;
       const {
         editConfig,
-        editStore,
-        editRules,
-        editOpts,
-        validOpts
-      } = this;
+        editRules
+      } = props;
+      const {
+        editStore
+      } = reactData;
       const {
         actived
       } = editStore;
+      const editOpts = $xeTable.computeEditOpts;
+      const validOpts = $xeTable.computeValidOpts;
       // 检查清除校验消息
       if (editRules && validOpts.msgMode === 'single') {
-        this.validErrorMaps = {};
+        reactData.validErrorMaps = {};
       }
       // 校验单元格
       if (editConfig && editRules && actived.row) {
@@ -585,10 +594,10 @@ var _default = exports.default = {
           column,
           cell
         } = actived.args;
-        if (this.hasCellRules(type, row, column)) {
-          return this.validCellRules(type, row, column).then(() => {
+        if ($xeTable.hasCellRules(type, row, column)) {
+          return $xeTable.validCellRules(type, row, column).then(() => {
             if (editOpts.mode === 'row') {
-              this.clearValidate(row, column);
+              $xeTable.clearValidate(row, column);
             }
           }).catch(({
             rule
@@ -601,7 +610,7 @@ var _default = exports.default = {
                 column,
                 cell
               };
-              this.showValidTooltip(rest);
+              $xeTable.showValidTooltip(rest);
               return Promise.reject(rest);
             }
             return Promise.resolve();
@@ -615,26 +624,29 @@ var _default = exports.default = {
      */
     showValidTooltip(params) {
       const $xeTable = this;
+      const props = $xeTable;
+      const reactData = $xeTable;
+      const {
+        height
+      } = props;
       const {
-        $refs,
-        height,
-        validStore,
-        validErrorMaps,
         tableData,
-        validOpts
-      } = this;
+        validStore,
+        validErrorMaps
+      } = reactData;
       const {
         rule,
         row,
         column,
         cell
       } = params;
-      const validTip = $refs.refValidTooltip;
+      const validOpts = $xeTable.computeValidOpts;
+      const validTip = $xeTable.$refs.refValidTooltip;
       const content = rule.content;
       validStore.visible = true;
       if (validOpts.msgMode === 'single') {
-        this.validErrorMaps = {
-          [`${(0, _util.getRowid)(this, row)}:${column.id}`]: {
+        reactData.validErrorMaps = {
+          [`${(0, _util.getRowid)($xeTable, row)}:${column.id}`]: {
             column,
             row,
             rule,
@@ -642,8 +654,8 @@ var _default = exports.default = {
           }
         };
       } else {
-        this.validErrorMaps = Object.assign({}, validErrorMaps, {
-          [`${(0, _util.getRowid)(this, row)}:${column.id}`]: {
+        reactData.validErrorMaps = Object.assign({}, validErrorMaps, {
+          [`${(0, _util.getRowid)($xeTable, row)}:${column.id}`]: {
             column,
             row,
             rule,
@@ -657,7 +669,7 @@ var _default = exports.default = {
           return validTip.open(cell, content);
         }
       }
-      return this.$nextTick();
+      return $xeTable.$nextTick();
     }
   }
 };