@opentiny/vue-renderless 3.1.0-alpha.0

package/grid/plugins/header.js

@@ -0,0 +1,58 @@
+var columnIsVisible = function columnIsVisible(children) {
+  return Array.isArray(children) && children.length && children.some(function (column) {
+    return column.visible;
+  });
+};
+export var getAllColumns = function getAllColumns(columns) {
+  var result = [];
+  columns.forEach(function (column) {
+    if (column.visible) {
+      var children = column.children;
+      if (columnIsVisible(children)) {
+        result.push(column);
+        result.push.apply(result, getAllColumns(children));
+      } else {
+        result.push(column);
+      }
+    }
+  });
+  return result;
+};
+export var convertToRows = function convertToRows(originColumns) {
+  var maxLevel = 1;
+  var walkTree = function walkTree(column, parent) {
+    if (parent) {
+      column.level = parent.level + 1;
+      if (maxLevel < column.level) {
+        maxLevel = column.level;
+      }
+    }
+    var children = column.children;
+    if (columnIsVisible(children)) {
+      var colSpan = 0;
+      children.forEach(function (childColumn) {
+        if (childColumn.visible) {
+          walkTree(childColumn, column);
+          colSpan += childColumn.colSpan;
+        }
+      });
+      column.colSpan = colSpan;
+    } else {
+      column.colSpan = 1;
+    }
+  };
+  originColumns.forEach(function (column) {
+    column.level = 1;
+    walkTree(column);
+  });
+  var allRows = [];
+  for (var i = 0; i < maxLevel; i++) {
+    allRows.push([]);
+  }
+  var allColumns = getAllColumns(originColumns);
+  allColumns.forEach(function (column) {
+    column.rowSpan = columnIsVisible(column.children) ? 1 : maxLevel - column.level + 1;
+    allRows[column.level - 1].push(column);
+  });
+  return allRows;
+};

package/grid/plugins/resize.js

@@ -0,0 +1,82 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import browser from '@opentiny/vue-renderless/common/browser';
+import { remove } from '../static';
+var resizeTimeout;
+var defaultInterval = 250;
+var eventStore = [];
+var eventHandle;
+var eventListener = function eventListener() {
+  clearTimeout(resizeTimeout);
+  resizeTimeout = setTimeout(eventHandle, defaultInterval);
+};
+eventHandle = function eventHandle() {
+  if (eventStore.length) {
+    eventStore.forEach(function (item) {
+      item.tarList.forEach(function (el) {
+        var target = el.target,
+          width = el.width,
+          heighe = el.heighe;
+        var clientWidth = target.clientWidth;
+        var clientHeight = target.clientHeight;
+        var rWidth = clientWidth && width !== clientWidth;
+        var rHeight = clientHeight && heighe !== clientHeight;
+        if (rWidth || rHeight) {
+          el.width = clientWidth;
+          el.heighe = clientHeight;
+          requestAnimationFrame(item.callback);
+        }
+      });
+    });
+    eventListener();
+  }
+};
+var ResizeObserverPolyfill = function () {
+  function ResizeObserverPolyfill(callback, resizeInterval) {
+    _classCallCheck(this, ResizeObserverPolyfill);
+    this.tarList = [];
+    this.callback = callback;
+    defaultInterval = resizeInterval;
+  }
+  _createClass(ResizeObserverPolyfill, [{
+    key: "observe",
+    value: function observe(targetObj) {
+      var _this = this;
+      if (targetObj) {
+        if (this.tarList.indexOf(targetObj) === -1) {
+          this.tarList.push({
+            target: targetObj,
+            width: targetObj.clientWidth,
+            heighe: targetObj.clientHeight
+          });
+        }
+        if (!eventStore.length) {
+          eventListener();
+        }
+        if (!eventStore.some(function (item) {
+          return item === _this;
+        })) {
+          eventStore.push(this);
+        }
+      }
+    }
+  }, {
+    key: "unobserve",
+    value: function unobserve(target) {
+      remove(eventStore, function (item) {
+        return ~item.tarList.indexOf(target);
+      });
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      var _this2 = this;
+      remove(eventStore, function (item) {
+        return item === _this2;
+      });
+    }
+  }]);
+  return ResizeObserverPolyfill;
+}();
+var Resize = browser.isDoc ? window.ResizeObserver || ResizeObserverPolyfill : ResizeObserverPolyfill;
+export default Resize;

package/grid/static/array/arrayEach.js

@@ -0,0 +1,12 @@
+var arrayEach = function arrayEach(obj, iterate, context) {
+  if (obj) {
+    if (obj.forEach) {
+      obj.forEach(iterate, context);
+    } else {
+      for (var index = 0, len = obj.length; index < len; index++) {
+        iterate.call(context, obj[index], index, obj);
+      }
+    }
+  }
+};
+export default arrayEach;

package/grid/static/array/arrayIndexOf.js

@@ -0,0 +1,11 @@
+var arrayIndexOf = function arrayIndexOf(obj, val) {
+  if (obj.indexOf) {
+    return obj.indexOf(val);
+  }
+  for (var index = 0, len = obj.length; index < len; index++) {
+    if (val === obj[index]) {
+      return index;
+    }
+  }
+};
+export default arrayIndexOf;

package/grid/static/array/eachTree.js

@@ -0,0 +1,32 @@
+import helperCreateTreeFunc from './helperCreateTreeFunc';
+import each from '../base/each';
+var eachTreeItem = function eachTreeItem(_ref) {
+  var parent = _ref.parent,
+    obj = _ref.obj,
+    iterate = _ref.iterate,
+    context = _ref.context,
+    path = _ref.path,
+    node = _ref.node,
+    parseChildren = _ref.parseChildren,
+    opts = _ref.opts;
+  each(obj, function (item, index) {
+    var paths = path.concat(["".concat(index)]);
+    var nodes = node.concat([item]);
+    iterate.call(context, item, index, obj, paths, parent, nodes);
+    if (item && parseChildren) {
+      paths.push(parseChildren);
+      eachTreeItem({
+        item: item,
+        obj: item[parseChildren],
+        context: context,
+        iterate: iterate,
+        node: nodes,
+        parseChildren: parseChildren,
+        path: paths,
+        opts: opts
+      });
+    }
+  });
+};
+var eachTree = helperCreateTreeFunc(eachTreeItem);
+export default eachTree;

package/grid/static/array/every.js

@@ -0,0 +1,2 @@
+import helperCreateIterateHandleFn from './helperCreateIterateHandle';
+export default helperCreateIterateHandleFn('every', 1, 1, false, true);

package/grid/static/array/filterTree.js

@@ -0,0 +1,16 @@
+import eachTree from './eachTree';
+var filterTree = function filterTree(obj, iterate, options, context) {
+  var result = [];
+  if (obj && iterate) {
+    eachTree(obj, function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (iterate.apply(context, args)) {
+        result.push(args[0]);
+      }
+    }, options);
+  }
+  return result;
+};
+export default filterTree;

package/grid/static/array/find.js

@@ -0,0 +1,3 @@
+import helperCreateIterateHandle from './helperCreateIterateHandle';
+var find = helperCreateIterateHandle('find', 1, 3, true);
+export default find;

package/grid/static/array/findTree.js

@@ -0,0 +1,46 @@
+import helperCreateTreeFunc from './helperCreateTreeFunc';
+var findTreeItem = function findTreeItem(_ref) {
+  var parent = _ref.parent,
+    obj = _ref.obj,
+    iterate = _ref.iterate,
+    context = _ref.context,
+    path = _ref.path,
+    node = _ref.node,
+    parseChildren = _ref.parseChildren,
+    opts = _ref.opts;
+  if (obj) {
+    for (var index = 0, len = obj.length; index < len; index++) {
+      var item = obj[index];
+      var paths = path.concat(["".concat(index)]);
+      var nodes = node.concat([item]);
+      if (iterate.call(context, item, index, obj, paths, parent, nodes)) {
+        return {
+          index: index,
+          item: item,
+          path: path,
+          items: obj,
+          parent: parent,
+          nodes: nodes
+        };
+      }
+      if (parseChildren && item) {
+        var newPath = paths.concat([parseChildren]);
+        var match = findTreeItem({
+          item: item,
+          obj: item[parseChildren],
+          iterate: iterate,
+          context: context,
+          path: newPath,
+          node: nodes,
+          parseChildren: parseChildren,
+          opts: opts
+        });
+        if (match) {
+          return match;
+        }
+      }
+    }
+  }
+};
+var findTree = helperCreateTreeFunc(findTreeItem);
+export default findTree;

package/grid/static/array/helperCreateIterateHandle.js

@@ -0,0 +1,59 @@
+import hasOwnProp from '../base/hasOwnProp';
+var handle = function handle(_ref) {
+  var useArray = _ref.useArray,
+    obj = _ref.obj,
+    iterate = _ref.iterate,
+    context = _ref.context,
+    matchValue = _ref.matchValue,
+    restIndex = _ref.restIndex;
+  var value,
+    flag = 0;
+  if (useArray && Array.isArray(obj)) {
+    for (var index = 0, len = obj.length; index < len; index++) {
+      if (!!iterate.call(context, obj[index], index, obj) === matchValue) {
+        value = [true, false, index, obj[index]][restIndex];
+        flag = 1;
+        break;
+      }
+    }
+  } else {
+    for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      if (hasOwnProp(obj, key)) {
+        if (!!iterate.call(context, obj[key], key, obj) === matchValue) {
+          value = [true, false, key, obj[key]][restIndex];
+          flag = 2;
+          break;
+        }
+      }
+    }
+  }
+  return {
+    value: value,
+    flag: flag
+  };
+};
+var helperCreateIterateHandle = function helperCreateIterateHandle(prop, useArray, restIndex, matchValue, defaultValue) {
+  return function (obj, iterate, context) {
+    if (!obj || !iterate) {
+      return defaultValue;
+    }
+    if (prop && obj[prop]) {
+      return obj[prop](iterate, context);
+    } else {
+      var ret = handle({
+        useArray: useArray,
+        obj: obj,
+        iterate: iterate,
+        context: context,
+        matchValue: matchValue,
+        restIndex: restIndex
+      });
+      if (ret.flag) {
+        return ret.value;
+      }
+    }
+    return defaultValue;
+  };
+};
+export default helperCreateIterateHandle;

package/grid/static/array/helperCreateTreeFunc.js

@@ -0,0 +1,18 @@
+var helperCreateTreeFunc = function helperCreateTreeFunc(handle) {
+  return function (obj, iterate, options, context) {
+    var opts = options || {};
+    var optChildren = opts.children || 'children';
+    var params = {
+      item: null,
+      obj: obj,
+      iterate: iterate,
+      context: context,
+      path: [],
+      node: [],
+      parseChildren: optChildren,
+      opts: opts
+    };
+    return handle(params);
+  };
+};
+export default helperCreateTreeFunc;

package/grid/static/array/includes.js

@@ -0,0 +1,5 @@
+import indexOf from '../base/indexOf';
+var includes = function includes(obj, val) {
+  return ~indexOf(obj, val);
+};
+export default includes;

package/grid/static/array/lastArrayEach.js

@@ -0,0 +1,6 @@
+var lastArrayEach = function lastArrayEach(obj, iterate, context) {
+  for (var len = obj.length - 1; len >= 0; len--) {
+    iterate.call(context, obj[len], len, obj);
+  }
+};
+export default lastArrayEach;

package/grid/static/array/map.js

@@ -0,0 +1,23 @@
+import each from '../base/each';
+import isFunction from '../base/isFunction';
+import property from '../function/property';
+var map = function map(obj, iterate, context) {
+  var result = [];
+  if (obj && arguments.length > 1) {
+    if (!isFunction(iterate)) {
+      iterate = property(iterate);
+    }
+    if (obj.map) {
+      return obj.map(iterate, context);
+    } else {
+      each(obj, function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        result.push(iterate.apply(context, args));
+      });
+    }
+  }
+  return result;
+};
+export default map;

package/grid/static/array/mapTree.js

@@ -0,0 +1,33 @@
+import helperCreateTreeFunc from './helperCreateTreeFunc';
+import map from './map';
+var mapTreeItem = function mapTreeItem(_ref) {
+  var parent = _ref.parent,
+    obj = _ref.obj,
+    iterate = _ref.iterate,
+    context = _ref.context,
+    path = _ref.path,
+    node = _ref.node,
+    parseChildren = _ref.parseChildren,
+    opts = _ref.opts;
+  var mapChildren = opts.mapChildren || parseChildren;
+  return map(obj, function (item, index) {
+    var paths = path.concat(["".concat(index)]);
+    var nodes = node.concat([item]);
+    var rest = iterate.call(context, item, index, obj, paths, parent, nodes);
+    if (rest && item && parseChildren && item[parseChildren]) {
+      rest[mapChildren] = mapTreeItem({
+        item: item,
+        obj: item[parseChildren],
+        iterate: iterate,
+        context: context,
+        path: paths,
+        node: nodes,
+        parseChildren: parseChildren,
+        opts: opts
+      });
+    }
+    return rest;
+  });
+};
+var mapTree = helperCreateTreeFunc(mapTreeItem);
+export default mapTree;

package/grid/static/array/slice.js

@@ -0,0 +1,10 @@
+var slice = function slice(array, startIndex, endIndex) {
+  var result = [];
+  if (array) {
+    for (startIndex = startIndex || 0, endIndex = endIndex || array.length; startIndex < endIndex; startIndex++) {
+      result.push(array[startIndex]);
+    }
+  }
+  return result;
+};
+export default slice;

package/grid/static/array/sortBy.js

@@ -0,0 +1,69 @@
+import arrayEach from './arrayEach';
+import toArray from './toArray';
+import map from './map';
+import isFunction from '../base/isFunction';
+import isUndefined from '../base/isUndefined';
+import isNull from '../base/isNull';
+import get from '../base/get';
+import property from '../function/property';
+var sortByDef = function sortByDef(v1, v2) {
+  if (isUndefined(v1) || isUndefined(v2)) {
+    return isUndefined(v2) ? 1 : -1;
+  }
+  if (isNull(v1) || isNull(v2)) {
+    return isNull(v2) ? 1 : -1;
+  }
+  return v1 && v1.localeCompare ? v1.localeCompare(v2) : v1 > v2 ? 1 : -1;
+};
+var sortMultis = function sortMultis(name, compares) {
+  return function (item1, item2) {
+    var v1 = item1[name];
+    var v2 = item2[name];
+    if (v1 === v2) {
+      return compares ? compares(item1, item2) : 0;
+    }
+    return sortByDef(v1, v2);
+  };
+};
+var getSortPros = function getSortPros(arr, list, iterate, context) {
+  iterate = Array.isArray(iterate) ? iterate : [iterate];
+  arrayEach(iterate, function (prop, index) {
+    var eachCallback;
+    if (isFunction(prop)) {
+      eachCallback = function eachCallback(val, key) {
+        val[index] = prop.call(context, val.data, key, arr);
+      };
+    } else {
+      eachCallback = function eachCallback(val) {
+        val[index] = get(val.data, prop);
+      };
+    }
+    arrayEach(list, eachCallback);
+  });
+  return iterate;
+};
+var sortBy = function sortBy(arr, iterate, context, STR_UNDEFINED) {
+  if (arr) {
+    if (iterate === STR_UNDEFINED) {
+      return toArray(arr).sort(sortByDef);
+    }
+    var compares;
+    var list = map(arr, function (item) {
+      return {
+        data: item
+      };
+    });
+    var sortPros = getSortPros(arr, list, iterate, context);
+    var len = sortPros.length;
+    if (len) {
+      while (len >= 0) {
+        compares = sortMultis(len, compares);
+        len--;
+      }
+      list = list.sort(compares);
+    }
+    return map(list, property('data'));
+  }
+  return [];
+};
+export default sortBy;

package/grid/static/array/sum.js

@@ -0,0 +1,28 @@
+import each from '../base/each';
+import isFunction from '../base/isFunction';
+import toNumber from '../number/toNumber';
+var sum = function sum(array, iterate, context) {
+  var result = 0;
+  var eachCallback;
+  if (iterate) {
+    if (isFunction(iterate)) {
+      eachCallback = function eachCallback() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        result += toNumber(iterate.apply(context, args));
+      };
+    } else {
+      eachCallback = function eachCallback(val) {
+        result += toNumber(val[iterate]);
+      };
+    }
+  } else {
+    eachCallback = function eachCallback(val) {
+      result += toNumber(val);
+    };
+  }
+  each(array, eachCallback);
+  return result;
+};
+export default sum;

package/grid/static/array/toArray.js

@@ -0,0 +1,7 @@
+import map from './map';
+var toArray = function toArray(arr) {
+  return map(arr, function (item) {
+    return item;
+  });
+};
+export default toArray;

package/grid/static/array/toTreeArray.js

@@ -0,0 +1,24 @@
+import each from '../base/each';
+import assign from '../object/assign';
+var defaultOptions = {
+  parentKey: 'parentId',
+  key: 'id',
+  children: 'children'
+};
+var unTreeList = function unTreeList(result, array, opts) {
+  var optChildren = opts.children;
+  var optData = opts.data;
+  each(array, function (item) {
+    var children = item[optChildren];
+    if (optData) {
+      item = item[optData];
+    }
+    result.push(item);
+    children && unTreeList(result, children, opts);
+  });
+  return result;
+};
+var toTreeArray = function toTreeArray(array, options) {
+  return unTreeList([], array, assign({}, defaultOptions, options));
+};
+export default toTreeArray;

package/grid/static/base/clear.js

@@ -0,0 +1,44 @@
+import isNull from './isNull';
+import isObject from './isObject';
+import assign from '../object/assign';
+import isPlainObject from './isPlainObject';
+import objectEach from '../object/objectEach';
+import helperDeleteProperty from './helperDeleteProperty';
+var clear = function clear(obj, defs, assigns) {
+  if (!obj) {
+    return obj;
+  }
+  var isDefs = arguments.length > 1 && (isNull(defs) || !isObject(defs));
+  var extds = isDefs ? assigns : defs;
+  if (isPlainObject(obj)) {
+    var eachCallback;
+    if (isDefs) {
+      eachCallback = function eachCallback(val, key) {
+        obj[key] = defs;
+      };
+    } else {
+      eachCallback = function eachCallback(val, key) {
+        helperDeleteProperty(obj, key);
+      };
+    }
+    objectEach(obj, eachCallback);
+    if (extds) {
+      assign(obj, extds);
+    }
+  } else if (Array.isArray(obj)) {
+    if (isDefs) {
+      var len = obj.length;
+      while (len > 0) {
+        len--;
+        obj[len] = defs;
+      }
+    } else {
+      obj.length = 0;
+    }
+    if (extds) {
+      obj.push.apply(obj, extds);
+    }
+  }
+  return obj;
+};
+export default clear;

package/grid/static/base/clone.js

@@ -0,0 +1,18 @@
+import isPlainObject from './isPlainObject';
+import objectMap from '../object/objectMap';
+import map from '../array/map';
+var deepClone;
+var startClone = function startClone(func, obj, deep) {
+  return func(obj, deep ? function (val) {
+    return deepClone(val, deep);
+  } : function (val) {
+    return val;
+  });
+};
+deepClone = function deepClone(val, deep) {
+  return isPlainObject(val) ? startClone(objectMap, val, deep) : Array.isArray(val) ? startClone(map, val, deep) : val;
+};
+var clone = function clone(obj, deep) {
+  return obj ? deepClone(obj, deep) : obj;
+};
+export default clone;

package/grid/static/base/destructuring.js

@@ -0,0 +1,18 @@
+import keys from './keys';
+import slice from '../array/slice';
+import assign from '../object/assign';
+import includes from '../array/includes';
+import arrayEach from '../array/arrayEach';
+var destructuring = function destructuring(destination, sources) {
+  if (destination && sources) {
+    var rest = assign.apply(this, [{}].concat(slice(arguments, 1)));
+    var restKeys = keys(rest);
+    arrayEach(keys(destination), function (key) {
+      if (includes(restKeys, key)) {
+        destination[key] = rest[key];
+      }
+    });
+  }
+  return destination;
+};
+export default destructuring;

package/grid/static/base/each.js

@@ -0,0 +1,9 @@
+import arrayEach from '../array/arrayEach';
+import objectEach from '../object/objectEach';
+var each = function each(obj, iterate, context) {
+  if (obj) {
+    return Array.isArray(obj) ? arrayEach(obj, iterate, context) : objectEach(obj, iterate, context);
+  }
+  return obj;
+};
+export default each;

package/grid/static/base/eqNull.js

@@ -0,0 +1,6 @@
+import isNullType from './isNull';
+import isUndefinedType from './isUndefined';
+var eqNull = function eqNull(object) {
+  return isNullType(object) || isUndefinedType(object);
+};
+export default eqNull;

package/grid/static/base/findIndexOf.js

@@ -0,0 +1,10 @@
+import helperCreateiterateIndexOf from './helperCreateiterateIndexOf';
+var findIndexOf = helperCreateiterateIndexOf(function (obj, iterate, context) {
+  for (var index = 0, len = obj.length; index < len; index++) {
+    if (iterate.call(context, obj[index], index, obj)) {
+      return index;
+    }
+  }
+  return -1;
+});
+export default findIndexOf;