@opentiny/vue-renderless 3.1.0-alpha.0

package/grid/static/index.js

@@ -0,0 +1,55 @@
+import assign from './object/assign';
+import extend from './object/extend';
+import objectEach from './object/objectEach';
+import lastObjectEach from './object/lastObjectEach';
+import objectMap from './object/objectMap';
+import values from './object/values';
+import map from './array/map';
+import every from './array/every';
+import find from './array/find';
+import arrayEach from './array/arrayEach';
+import lastArrayEach from './array/lastArrayEach';
+import toArray from './array/toArray';
+import sortBy from './array/sortBy';
+import slice from './array/slice';
+import includes from './array/includes';
+import sum from './array/sum';
+import toTreeArray from './array/toTreeArray';
+import findTree from './array/findTree';
+import eachTree from './array/eachTree';
+import mapTree from './array/mapTree';
+import filterTree from './array/filterTree';
+import arrayIndexOf from './array/arrayIndexOf';
+import isNull from './base/isNull';
+import isUndefined from './base/isUndefined';
+import isFunction from './base/isFunction';
+import isObject from './base/isObject';
+import isString from './base/isString';
+import isPlainObject from './base/isPlainObject';
+import eqNull from './base/eqNull';
+import each from './base/each';
+import indexOf from './base/indexOf';
+import keys from './base/keys';
+import clone from './base/clone';
+import lastEach from './base/lastEach';
+import remove from './base/remove';
+import clear from './base/clear';
+import isBoolean from './base/isBoolean';
+import isNumber from './base/isNumber';
+import isEmpty from './base/isEmpty';
+import isSet from './base/isSet';
+import isEqual from './base/isEqual';
+import uniqueId from './base/uniqueId';
+import findIndexOf from './base/findIndexOf';
+import toStringJSON from './base/toStringJSON';
+import toJSONString from './base/toJSONString';
+import has from './base/has';
+import get from './base/get';
+import set from './base/set';
+import destructuring from './base/destructuring';
+import toNumber from './number/toNumber';
+import template from './string/template';
+import toString from './string/toString';
+import property from './function/property';
+var isArray = Array.isArray;
+export { assign, extend, objectEach, lastObjectEach, objectMap, values, map, every, find, arrayEach, lastArrayEach, toArray, sortBy, slice, includes, sum, toTreeArray, findTree, eachTree, mapTree, filterTree, arrayIndexOf, isArray, isNull, isUndefined, isFunction, isObject, isString, isPlainObject, eqNull, each, indexOf, keys, clone, lastEach, remove, clear, isBoolean, isNumber, isEmpty, isSet, isEqual, uniqueId, findIndexOf, toStringJSON, toJSONString, has, get, set, destructuring, toNumber, template, toString, property };

package/grid/static/number/helperCreateToNumber.js

@@ -0,0 +1,12 @@
+var helperCreateToNumber = function helperCreateToNumber(handle) {
+  return function (str) {
+    if (str) {
+      var num = handle(str);
+      if (!isNaN(num)) {
+        return num;
+      }
+    }
+    return 0;
+  };
+};
+export default helperCreateToNumber;

package/grid/static/number/toNumber.js

@@ -0,0 +1,3 @@
+import helperCreateToNumber from './helperCreateToNumber';
+var toNumber = helperCreateToNumber(parseFloat);
+export default toNumber;

package/grid/static/object/assign.js

@@ -0,0 +1,41 @@
+import arrayEach from '../array/arrayEach';
+import keys from '../base/keys';
+import clone from '../base/clone';
+var objectAssignFns = Object.assign;
+var handleAssign = function handleAssign(destination, args, isClone) {
+  var len = args.length;
+  var _loop = function _loop(_source, index) {
+    _source = args[index];
+    var eachCallback = void 0;
+    if (isClone) {
+      eachCallback = function eachCallback(key) {
+        destination[key] = clone(_source[key], isClone);
+      };
+    } else {
+      eachCallback = function eachCallback(key) {
+        destination[key] = _source[key];
+      };
+    }
+    arrayEach(keys(args[index]), eachCallback);
+    source = _source;
+  };
+  for (var source, index = 1; index < len; index++) {
+    _loop(source, index);
+  }
+  return destination;
+};
+var assign = function assign(target) {
+  if (target) {
+    var args = arguments;
+    if (target === true) {
+      if (args.length > 1) {
+        target = Array.isArray(target[1]) ? [] : {};
+        return handleAssign(target, args, true);
+      }
+    } else {
+      return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args);
+    }
+  }
+  return target;
+};
+export default assign;

package/grid/static/object/extend.js

@@ -0,0 +1,3 @@
+import assign from './assign';
+var extend = assign;
+export default extend;

package/grid/static/object/lastObjectEach.js

@@ -0,0 +1,8 @@
+import lastArrayEach from '../array/lastArrayEach';
+import keys from '../base/keys';
+var lastObjectEach = function lastObjectEach(obj, iterate, context) {
+  lastArrayEach(keys(obj), function (key) {
+    iterate.call(context, obj[key], key, obj);
+  });
+};
+export default lastObjectEach;

package/grid/static/object/objectEach.js

@@ -0,0 +1,11 @@
+import hasOwnProp from '../base/hasOwnProp';
+var objectEach = function objectEach(obj, iterate, context) {
+  if (obj) {
+    Object.keys(obj).forEach(function (key) {
+      if (hasOwnProp(obj, key)) {
+        iterate.call(context, obj[key], key, obj);
+      }
+    });
+  }
+};
+export default objectEach;

package/grid/static/object/objectMap.js

@@ -0,0 +1,20 @@
+import each from '../base/each';
+import isFunction from '../base/isFunction';
+import property from '../function/property';
+var objectMap = function objectMap(obj, iterate, context) {
+  var result = {};
+  if (obj) {
+    if (iterate) {
+      if (!isFunction(iterate)) {
+        iterate = property(iterate);
+      }
+      each(obj, function (val, index) {
+        result[index] = iterate.call(context, val, index, obj);
+      });
+    } else {
+      return obj;
+    }
+  }
+  return result;
+};
+export default objectMap;

package/grid/static/object/values.js

@@ -0,0 +1,9 @@
+import objectEach from './objectEach';
+var values = function values(obj, iterator, ctx) {
+  var objectValues = [];
+  objectEach(obj, function (val) {
+    objectValues.push(val);
+  }, ctx);
+  return objectValues;
+};
+export default values;

package/grid/static/static/staticDocument.js

@@ -0,0 +1,4 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import staticStrUndefined from './staticStrUndefined';
+var staticDocument = (typeof document === "undefined" ? "undefined" : _typeof(document)) === staticStrUndefined ? 0 : document;
+export default staticDocument;

package/grid/static/static/staticHGKeyRE.js

@@ -0,0 +1,2 @@
+var staticHGKeyRE = /(.+)?\[(\d+)\]$/;
+export default staticHGKeyRE;

package/grid/static/static/staticParseInt.js

@@ -0,0 +1,2 @@
+var staticParseInt = parseInt;
+export default staticParseInt;

package/grid/static/static/staticStrUndefined.js

@@ -0,0 +1,2 @@
+var staticStrUndefined = 'undefined';
+export default staticStrUndefined;

package/grid/static/static/staticWindow.js

@@ -0,0 +1,4 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import staticStrUndefined from './staticStrUndefined';
+var staticWindow = (typeof window === "undefined" ? "undefined" : _typeof(window)) === staticStrUndefined ? 0 : window;
+export default staticWindow;

package/grid/static/string/template.js

@@ -0,0 +1,12 @@
+import toValString from './toString';
+import get from '../base/get';
+var template = function template(str, obj) {
+  var rest = toValString(str);
+  if (rest && obj) {
+    return rest.replace(/\{{2}([.\w[\]\s]+)\}{2}/g, function (match, keys) {
+      return get(obj, keys);
+    });
+  }
+  return rest;
+};
+export default template;

package/grid/static/string/toString.js

@@ -0,0 +1,12 @@
+import eqNull from '../base/eqNull';
+import isNumber from '../base/isNumber';
+var toValString = function toValString(obj) {
+  if (isNumber(obj)) {
+    if (('' + obj).indexOf('e-') >= 0) {
+      var isNegative = obj < 0;
+      return (isNegative ? '-' : '') + '0' + ('' + ((isNegative ? Math.abs(obj) : obj) + 1)).substr(1);
+    }
+  }
+  return '' + (eqNull(obj) ? '' : obj);
+};
+export default toValString;

package/grid/utils/column.js

@@ -0,0 +1,72 @@
+import { isBoolean } from '../static';
+import { initFilter } from './common';
+var columnUniqueId = 0;
+function setBasicProperty(column, context) {
+  column.id = "col_".concat(++columnUniqueId);
+  column.type = context.type;
+  column.prop = context.prop;
+  column.rules = context.rules;
+  column.required = context.required;
+  column.property = context.field || context.prop;
+  column.title = context.title;
+  column.label = context.label;
+  column.width = context.width;
+  column.minWidth = context.minWidth;
+  column.resizable = context.resizable;
+  column.fixed = context.fixed;
+  column.align = context.align;
+  column.headerAlign = context.headerAlign;
+  column.footerAlign = context.footerAlign;
+  column.showOverflow = context.showOverflow;
+  column.showHeaderOverflow = context.showHeaderOverflow;
+  column.showTip = context.showTip;
+  column.showHeaderTip = context.showHeaderTip;
+  column.className = context["class"] || context.className;
+  column.headerClassName = context.headerClassName;
+  column.footerClassName = context.footerClassName;
+  column.indexMethod = context.indexMethod;
+  column.formatText = context.formatText;
+  column.formatValue = context.formatValue;
+  column.format = context.formatConfig;
+  column.sortable = context.sortable;
+  column.sortBy = context.sortBy;
+  column.sortMethod = context.sortMethod;
+  column.remoteSort = context.remoteSort;
+  column.filterMultiple = isBoolean(context.filterMultiple) ? context.filterMultiple : true;
+  column.filterMethod = context.filterMethod;
+  column.filterRender = context.filterRender;
+  column.filter = context.filter && initFilter(context.filter);
+  column.treeNode = context.treeNode;
+  column.renderer = context.renderer;
+  column.editor = context.editor;
+}
+function ColumnConfig(context) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    renderHeader = _ref.renderHeader,
+    renderCell = _ref.renderCell,
+    renderData = _ref.renderData;
+  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  setBasicProperty(this, context);
+  this.params = context.params;
+  this.visible = true;
+  this.level = 1;
+  this.rowSpan = 1;
+  this.colSpan = 1;
+  this.order = null;
+  this.renderWidth = 0;
+  this.renderHeight = 0;
+  this.resizeWidth = 0;
+  this.renderLeft = 0;
+  this.model = {};
+  this.renderHeader = renderHeader || context.renderHeader;
+  this.renderCell = renderCell || context.renderCell;
+  this.renderData = renderData;
+  this.showIcon = isBoolean(context.showIcon) ? context.showIcon : true;
+  this.loading = false;
+  this.slots = context.slots;
+  this.own = context;
+  this.asyncPrefix = config.constant.asyncPrefix;
+}
+export var getColumnConfig = function getColumnConfig(context, options, config) {
+  return context instanceof ColumnConfig ? context : new ColumnConfig(context, options, config);
+};

package/grid/utils/common.js

@@ -0,0 +1,155 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { extend } from '@opentiny/vue-renderless/common/object';
+import { isNull } from '@opentiny/vue-renderless/common/type';
+import { find } from '@opentiny/vue-renderless/common/array';
+import { get, isFunction, set, findTree } from '../static';
+export var gridSize = ['medium', 'small', 'mini'];
+export var getSize = function getSize(_ref) {
+  var size = _ref.size,
+    $parent = _ref.$parent;
+  return size || ($parent && gridSize.indexOf($parent.size) > -1 ? $parent.size : null);
+};
+export var getFuncText = function getFuncText(content) {
+  return isFunction(content) ? content() : content;
+};
+export var getRowkey = function getRowkey($table) {
+  return $table.rowId;
+};
+export var getRowid = function getRowid($table, row) {
+  var rowId = get(row, getRowkey($table));
+  return rowId ? encodeURIComponent(rowId) : '';
+};
+export var getColumnList = function getColumnList(columns) {
+  var result = [];
+  columns.forEach(function (column) {
+    result.push.apply(result, column.children && column.children.length ? getColumnList(column.children) : [column]);
+  });
+  return result;
+};
+export var getClass = function getClass(property, params) {
+  return property ? isFunction(property) ? property(params) : property : '';
+};
+export var getFilters = function getFilters(filters) {
+  return (filters || []).map(function (_ref2) {
+    var label = _ref2.label,
+      value = _ref2.value,
+      data = _ref2.data,
+      checked = _ref2.checked;
+    return {
+      label: label,
+      value: value,
+      data: data,
+      _data: data,
+      checked: !!checked
+    };
+  });
+};
+export var initFilter = function initFilter(filter) {
+  var filterOpt = extend({}, filter, true);
+  filterOpt.condition = {
+    input: '',
+    relation: 'equals',
+    empty: null,
+    type: null,
+    value: []
+  };
+  filterOpt.hasFilter = false;
+  filterOpt.custom = null;
+  return filterOpt;
+};
+export var formatText = function formatText(value) {
+  return "".concat(isNull(value) ? '' : value);
+};
+export var setCellValue = function setCellValue(row, column, value) {
+  var format = column.format,
+    property = column.property;
+  if (format && format.async && Array.isArray(format.data) && format.data.length > 0 && value) {
+    var labelText = '';
+    var _ref3 = format.async.splitConfig || {},
+      enabled = _ref3.enabled,
+      valueSplit = _ref3.valueSplit,
+      textSplit = _ref3.textSplit;
+    var findCellValue = function findCellValue(optionValue) {
+      return find(format.data, function (col) {
+        if (_typeof(col) === 'object') {
+          var colLabel = get(col, format.async.text || 'label');
+          var colValue = get(col, format.async.value || 'value');
+          col.label = colLabel;
+          return optionValue === colValue || optionValue === colLabel;
+        }
+        return optionValue === col;
+      });
+    };
+    if (enabled) {
+      var labelTexts = [];
+      value.split(valueSplit || ',').forEach(function (item) {
+        var findValue = findCellValue(item);
+        if (findValue) {
+          labelTexts.push(findValue.label);
+        }
+      });
+      labelText = labelTexts.join(textSplit || ',');
+    } else {
+      labelText = findCellValue(value);
+    }
+    set(row, column.asyncPrefix + property, labelText ? labelText.label : labelText);
+  }
+  set(row, property, value);
+};
+export var hasChildrenList = function hasChildrenList(item) {
+  return item && item.children && item.children.length > 0;
+};
+export var destroyColumn = function destroyColumn($table, _ref4) {
+  var columnConfig = _ref4.columnConfig;
+  var matchObj = findTree($table.collectColumn, function (column) {
+    return column === columnConfig;
+  });
+  if (matchObj) {
+    matchObj.items.splice(matchObj.index, 1);
+  }
+  $table.collectColumn = $table.collectColumn.slice(0);
+};
+export var emitEvent = function emitEvent(vnode, type, args) {
+  if (vnode.tableListeners[type]) {
+    vnode.$emit.apply(vnode, [type].concat(args));
+  }
+};
+export var assemColumn = function assemColumn($table, $column, instance) {
+  var columnConfig = instance.columnConfig,
+    elm = instance.$el,
+    $scopedSlots = instance.$scopedSlots,
+    $slots = instance.$slots,
+    $parent = instance.$parent;
+  var collectColumn = $table.collectColumn;
+  columnConfig.slots = $scopedSlots || $slots;
+  var parentNode = elm.parentNode;
+  var insertIndex = [].indexOf.call(parentNode.children, elm);
+  if (!$column || $column !== $parent) {
+    collectColumn.splice(insertIndex, 0, columnConfig);
+  } else {
+    var parentConfig = $column.columnConfig;
+    if (!parentConfig.children) {
+      parentConfig.children = [];
+    }
+    parentConfig.children.splice(insertIndex, 0, columnConfig);
+  }
+  $table.collectColumn = collectColumn.slice(0);
+};
+export var getCellValue = function getCellValue(row, column) {
+  return get(row, column.property);
+};
+export var getListeners = function getListeners($attrs, $listeners) {
+  var regHyphenate = /\B([A-Z])/g;
+  var regEventPrefix = /^on[A-Z]/;
+  var listeners = {};
+  if ($listeners) {
+    return $listeners;
+  }
+  Object.keys($attrs).forEach(function (name) {
+    var event = $attrs[name];
+    if (regEventPrefix.test(name) && typeof event === 'function') {
+      listeners[name.substr(2).replace(regHyphenate, '-$1').toLowerCase()] = event;
+    }
+  });
+  return listeners;
+};

package/grid/utils/dom.js

@@ -0,0 +1,213 @@
+import { getRowid } from './common';
+import { hasClass } from '@opentiny/vue-renderless/common/deps/dom';
+import { arrayIndexOf } from '../static';
+var ATTR_NAME = 'data-rowid';
+var CELL_CLS = '.tiny-grid-cell';
+var ROW_CLS = '.tiny-grid-body__row';
+var htmlEl = document.querySelector('html');
+var bodyEl = document.body;
+export var isPx = function isPx(val) {
+  return val && /^\d+(px)?$/.test(val);
+};
+export var isScale = function isScale(val) {
+  return val && /^\d+%$/.test(val);
+};
+export var updateCellTitle = function updateCellTitle(event) {
+  var cellEl = event.currentTarget.querySelector(CELL_CLS);
+  var content = cellEl.innerText;
+  if (cellEl.getAttribute('title') !== content) {
+    cellEl.setAttribute('title', content);
+  }
+};
+export var rowToVisible = function rowToVisible($table, row) {
+  $table.$nextTick(function () {
+    var tableBodyVnode = $table.$refs.tableBody;
+    if (tableBodyVnode) {
+      var gridbodyEl = tableBodyVnode.$el;
+      var trEl = gridbodyEl.querySelector("[".concat(ATTR_NAME, "=\"").concat(getRowid($table, row), "\"]"));
+      if (trEl) {
+        var bodyHeight = gridbodyEl.clientHeight;
+        var bodySrcollTop = gridbodyEl.scrollTop;
+        var trOffsetTop = trEl.offsetTop + (trEl.offsetParent ? trEl.offsetParent.offsetTop : 0);
+        var trHeight = trEl.clientHeight;
+        if (trOffsetTop < bodySrcollTop || trOffsetTop > bodySrcollTop + bodyHeight) {
+          gridbodyEl.scrollTop = trOffsetTop;
+        } else if (trOffsetTop + trHeight >= bodyHeight + bodySrcollTop) {
+          gridbodyEl.scrollTop = bodySrcollTop + trHeight;
+        }
+      } else {
+        if ($table.scrollYLoad) {
+          gridbodyEl.scrollTop = ($table.afterFullData.indexOf(row) - 1) * $table.scrollYStore.rowHeight;
+        }
+      }
+    }
+  });
+};
+function getFixedLeft($table, from, column, body, offset) {
+  var scrollLeft = $table.elemStore['main-body-wrapper'].scrollLeft + offset;
+  if (!column.fixed) {
+    from.fixed === 'left' && (scrollLeft = 0);
+    from.fixed === 'right' && (scrollLeft = body.scrollWidth);
+  }
+  return scrollLeft;
+}
+function setBodyLeft(body, td, $table, column, move) {
+  var _ref = move || {},
+    isLeftArrow = _ref.isLeftArrow,
+    isRightArrow = _ref.isRightArrow,
+    from = _ref.from;
+  var bodyWidth = body.clientWidth;
+  var bodySrcollLeft = body.scrollLeft;
+  var tdOffsetLeft = td.offsetLeft + (td.offsetParent ? td.offsetParent.offsetLeft : 0);
+  var tdWidth = td.clientWidth;
+  if (tdOffsetLeft < bodySrcollLeft || tdOffsetLeft > bodySrcollLeft + bodyWidth) {
+    from !== column && (body.scrollLeft = tdOffsetLeft);
+  } else if (tdOffsetLeft + tdWidth >= bodyWidth + bodySrcollLeft) {
+    body.scrollLeft = bodySrcollLeft + tdWidth;
+  }
+  if (from) {
+    var direction = isLeftArrow ? 'left' : isRightArrow ? 'right' : null;
+    var fixedDom = $table.elemStore["".concat(direction, "-body-list")];
+    var mainBody = $table.elemStore['main-body-wrapper'];
+    var _td$getBoundingClient = td.getBoundingClientRect(),
+      left = _td$getBoundingClient.left,
+      right = _td$getBoundingClient.right;
+    var offset = 0;
+    if (isLeftArrow && fixedDom) {
+      var div = fixedDom.querySelector('td.fixed__hidden');
+      var division = div ? div.getBoundingClientRect().left : fixedDom.getBoundingClientRect().right;
+      division > left && (offset = left - division);
+    }
+    if (isRightArrow && fixedDom) {
+      var _div = fixedDom.querySelector('td:not(.fixed__hidden)') || fixedDom;
+      var _division = _div.getBoundingClientRect().left;
+      _division < right && (offset = right - _division);
+    }
+    mainBody.scrollLeft = getFixedLeft($table, from, column, body, offset);
+  }
+}
+export var colToVisible = function colToVisible($table, column, move) {
+  $table.$nextTick(function () {
+    var gridbodyEl = $table.$refs.tableBody.$el;
+    var tdElem = gridbodyEl.querySelector(".".concat(column.id));
+    if (tdElem) {
+      setBodyLeft(gridbodyEl, tdElem, $table, column, move);
+    } else if ($table.scrollXLoad) {
+      var visibleColumn = $table.visibleColumn;
+      var scrollLeft = 0;
+      for (var index = 0; index < visibleColumn.length; index++) {
+        if (visibleColumn[index] === column) {
+          break;
+        }
+        scrollLeft += visibleColumn[index].renderWidth;
+      }
+      gridbodyEl.scrollLeft = scrollLeft;
+    }
+  });
+};
+export var getDomNode = function getDomNode() {
+  var documentElement = document.documentElement;
+  var bodyElement = document.body;
+  return {
+    scrollTop: documentElement.scrollTop || bodyElement.scrollTop,
+    scrollLeft: documentElement.scrollLeft || bodyElement.scrollLeft,
+    visibleHeight: documentElement.clientHeight || bodyElement.clientHeight,
+    visibleWidth: documentElement.clientWidth || bodyElement.clientWidth
+  };
+};
+export var getEventTargetNode = function getEventTargetNode(event, container, queryCls) {
+  var targetEl;
+  var target = event.target;
+  while (target && target.nodeType && target !== document) {
+    if (queryCls && hasClass(target, queryCls)) {
+      targetEl = target;
+    } else if (target === container) {
+      return {
+        flag: queryCls ? !!targetEl : true,
+        container: container,
+        targetElem: targetEl
+      };
+    }
+    target = target.parentNode;
+  }
+  return {
+    flag: false
+  };
+};
+function getNodeOffset(el, container, rest) {
+  if (el) {
+    var parentEl = el.parentNode;
+    rest.top += el.offsetTop;
+    rest.left += el.offsetLeft;
+    if (parentEl && parentEl !== htmlEl && parentEl !== bodyEl) {
+      rest.top -= parentEl.scrollTop;
+      rest.left -= parentEl.scrollLeft;
+    }
+    if (container && (el === container || el.offsetParent === container) ? 0 : el.offsetParent) {
+      return getNodeOffset(el.offsetParent, container, rest);
+    }
+  }
+  return rest;
+}
+export var getOffsetPos = function getOffsetPos(el, container) {
+  return getNodeOffset(el, container, {
+    left: 0,
+    top: 0
+  });
+};
+export var getAbsolutePos = function getAbsolutePos(el) {
+  var bounding = el.getBoundingClientRect();
+  var _getDomNode = getDomNode(),
+    scrollTop = _getDomNode.scrollTop,
+    scrollLeft = _getDomNode.scrollLeft;
+  return {
+    top: scrollTop + bounding.top,
+    left: scrollLeft + bounding.left
+  };
+};
+export var getCellNodeIndex = function getCellNodeIndex(cell) {
+  var trEl = cell.parentNode;
+  var columnIndex = arrayIndexOf(trEl.children, cell);
+  var rowIndex = arrayIndexOf(trEl.parentNode.children, trEl);
+  return {
+    columnIndex: columnIndex,
+    rowIndex: rowIndex
+  };
+};
+export var getRowNodes = function getRowNodes(trList, cellNode, targetCellNode) {
+  var startColIndex = cellNode.columnIndex;
+  var startRowIndex = cellNode.rowIndex;
+  var targetColIndex = targetCellNode.columnIndex;
+  var targetRowIndex = targetCellNode.rowIndex;
+  var rows = [];
+  for (var rowIndex = Math.min(startRowIndex, targetRowIndex), rowLen = Math.max(startRowIndex, targetRowIndex); rowIndex <= rowLen; rowIndex++) {
+    var cells = [];
+    var trEl = trList[rowIndex];
+    for (var colIndex = Math.min(startColIndex, targetColIndex), colLen = Math.max(startColIndex, targetColIndex); colIndex <= colLen; colIndex++) {
+      cells.push(trEl.children[colIndex]);
+    }
+    rows.push(cells);
+  }
+  return rows;
+};
+export var getCellIndexs = function getCellIndexs(cell) {
+  var trEl = cell.parentNode;
+  var rowid = trEl.getAttribute(ATTR_NAME);
+  var columnIndex = [].indexOf.call(trEl.children, cell);
+  var rowIndex = [].indexOf.call(trEl.parentNode.children, trEl);
+  return {
+    rowid: rowid,
+    rowIndex: rowIndex,
+    columnIndex: columnIndex
+  };
+};
+export var getCell = function getCell($table, _ref2) {
+  var row = _ref2.row,
+    column = _ref2.column;
+  return new Promise(function (resolve) {
+    $table.$nextTick(function () {
+      var bodyElem = $table.$refs["".concat(column.fixed || 'table', "Body")];
+      resolve((bodyElem || $table.$refs.tableBody).$el.querySelector("".concat(ROW_CLS, "[").concat(ATTR_NAME, "=\"").concat(getRowid($table, row), "\"] .").concat(column.id)));
+    });
+  });
+};