@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/grid/plugins/header.js

@@ -1,13 +1,10 @@
-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) {
+import "../../chunk-PKUHTIDK.js";
+const columnIsVisible = (children) => Array.isArray(children) && children.length && children.some((column) => column.visible);
+const getAllColumns = (columns) => {
+  const result = [];
+  columns.forEach((column) => {
     if (column.visible) {
-      var children = column.children;
+      const children = column.children;
       if (columnIsVisible(children)) {
         result.push(column);
         result.push.apply(result, getAllColumns(children));
@@ -18,19 +15,19 @@ export var getAllColumns = function getAllColumns(columns) {
   });
   return result;
 };
-export var convertToRows = function convertToRows(originColumns) {
-  var maxLevel = 1;
-  var walkTree = function walkTree(column, parent) {
+const convertToRows = (originColumns) => {
+  let maxLevel = 1;
+  const walkTree = (column, parent) => {
     if (parent) {
       column.level = parent.level + 1;
       if (maxLevel < column.level) {
         maxLevel = column.level;
       }
     }
-    var children = column.children;
+    const children = column.children;
     if (columnIsVisible(children)) {
-      var colSpan = 0;
-      children.forEach(function (childColumn) {
+      let colSpan = 0;
+      children.forEach((childColumn) => {
         if (childColumn.visible) {
           walkTree(childColumn, column);
           colSpan += childColumn.colSpan;
@@ -41,18 +38,22 @@ export var convertToRows = function convertToRows(originColumns) {
       column.colSpan = 1;
     }
   };
-  originColumns.forEach(function (column) {
+  originColumns.forEach((column) => {
     column.level = 1;
     walkTree(column);
   });
-  var allRows = [];
-  for (var i = 0; i < maxLevel; i++) {
+  const allRows = [];
+  for (let i = 0; i < maxLevel; i++) {
     allRows.push([]);
   }
-  var allColumns = getAllColumns(originColumns);
-  allColumns.forEach(function (column) {
+  const allColumns = getAllColumns(originColumns);
+  allColumns.forEach((column) => {
     column.rowSpan = columnIsVisible(column.children) ? 1 : maxLevel - column.level + 1;
     allRows[column.level - 1].push(column);
   });
   return allRows;
-};
+};
+export {
+  convertToRows,
+  getAllColumns
+};

package/grid/plugins/resize.js

@@ -1,26 +1,23 @@
-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() {
+import "../../chunk-PKUHTIDK.js";
+import browser from "@opentiny/vue-renderless/common/browser";
+import { remove } from "../static";
+let resizeTimeout;
+let defaultInterval = 250;
+const eventStore = [];
+let eventHandle;
+const eventListener = () => {
   clearTimeout(resizeTimeout);
   resizeTimeout = setTimeout(eventHandle, defaultInterval);
 };
-eventHandle = function eventHandle() {
+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;
+    eventStore.forEach((item) => {
+      item.tarList.forEach((el) => {
+        const { target, width, heighe } = el;
+        const clientWidth = target.clientWidth;
+        const clientHeight = target.clientHeight;
+        const rWidth = clientWidth && width !== clientWidth;
+        const rHeight = clientHeight && heighe !== clientHeight;
         if (rWidth || rHeight) {
           el.width = clientWidth;
           el.heighe = clientHeight;
@@ -31,52 +28,38 @@ eventHandle = function eventHandle() {
     eventListener();
   }
 };
-var ResizeObserverPolyfill = function () {
-  function ResizeObserverPolyfill(callback, resizeInterval) {
-    _classCallCheck(this, ResizeObserverPolyfill);
+class ResizeObserverPolyfill {
+  constructor(callback, resizeInterval) {
     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);
-        }
+  observe(targetObj) {
+    if (targetObj) {
+      if (!this.tarList.includes(targetObj)) {
+        this.tarList.push({
+          target: targetObj,
+          width: targetObj.clientWidth,
+          heighe: targetObj.clientHeight
+        });
+      }
+      if (!eventStore.length) {
+        eventListener();
+      }
+      if (!eventStore.includes(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;
+  }
+  unobserve(target) {
+    remove(eventStore, (item) => ~item.tarList.indexOf(target));
+  }
+  disconnect() {
+    remove(eventStore, (item) => item === this);
+  }
+}
+const Resize = browser.isDoc ? window.ResizeObserver || ResizeObserverPolyfill : ResizeObserverPolyfill;
+var resize_default = Resize;
+export {
+  resize_default as default
+};

package/grid/static/array/arrayEach.js

@@ -1,12 +1,16 @@
-var arrayEach = function arrayEach(obj, iterate, context) {
+import "../../../chunk-PKUHTIDK.js";
+const arrayEach = (obj, iterate, context) => {
   if (obj) {
     if (obj.forEach) {
       obj.forEach(iterate, context);
     } else {
-      for (var index = 0, len = obj.length; index < len; index++) {
+      for (let index = 0, len = obj.length; index < len; index++) {
         iterate.call(context, obj[index], index, obj);
       }
     }
   }
 };
-export default arrayEach;
+var arrayEach_default = arrayEach;
+export {
+  arrayEach_default as default
+};

package/grid/static/array/arrayIndexOf.js

@@ -1,11 +1,15 @@
-var arrayIndexOf = function arrayIndexOf(obj, val) {
+import "../../../chunk-PKUHTIDK.js";
+const arrayIndexOf = (obj, val) => {
   if (obj.indexOf) {
     return obj.indexOf(val);
   }
-  for (var index = 0, len = obj.length; index < len; index++) {
+  for (let index = 0, len = obj.length; index < len; index++) {
     if (val === obj[index]) {
       return index;
     }
   }
 };
-export default arrayIndexOf;
+var arrayIndexOf_default = arrayIndexOf;
+export {
+  arrayIndexOf_default as default
+};

package/grid/static/array/eachTree.js

@@ -1,32 +1,28 @@
-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]);
+import "../../../chunk-PKUHTIDK.js";
+import helperCreateTreeFunc from "./helperCreateTreeFunc";
+import each from "../base/each";
+const eachTreeItem = ({ parent, obj, iterate, context, path, node, parseChildren, opts }) => {
+  each(obj, (item, index) => {
+    const paths = path.concat([`${index}`]);
+    const nodes = node.concat([item]);
     iterate.call(context, item, index, obj, paths, parent, nodes);
     if (item && parseChildren) {
       paths.push(parseChildren);
       eachTreeItem({
-        item: item,
+        item,
         obj: item[parseChildren],
-        context: context,
-        iterate: iterate,
+        context,
+        iterate,
         node: nodes,
-        parseChildren: parseChildren,
+        parseChildren,
         path: paths,
-        opts: opts
+        opts
       });
     }
   });
 };
-var eachTree = helperCreateTreeFunc(eachTreeItem);
-export default eachTree;
+const eachTree = helperCreateTreeFunc(eachTreeItem);
+var eachTree_default = eachTree;
+export {
+  eachTree_default as default
+};

package/grid/static/array/every.js

@@ -1,2 +1,6 @@
-import helperCreateIterateHandleFn from './helperCreateIterateHandle';
-export default helperCreateIterateHandleFn('every', 1, 1, false, true);
+import "../../../chunk-PKUHTIDK.js";
+import helperCreateIterateHandleFn from "./helperCreateIterateHandle";
+var every_default = helperCreateIterateHandleFn("every", 1, 1, false, true);
+export {
+  every_default as default
+};

package/grid/static/array/filterTree.js

@@ -1,16 +1,21 @@
-import eachTree from './eachTree';
-var filterTree = function filterTree(obj, iterate, options, context) {
-  var result = [];
+import "../../../chunk-PKUHTIDK.js";
+import eachTree from "./eachTree";
+const filterTree = (obj, iterate, options, context) => {
+  let 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);
+    eachTree(
+      obj,
+      (...args) => {
+        if (iterate.apply(context, args)) {
+          result.push(args[0]);
+        }
+      },
+      options
+    );
   }
   return result;
 };
-export default filterTree;
+var filterTree_default = filterTree;
+export {
+  filterTree_default as default
+};

package/grid/static/array/find.js

@@ -1,3 +1,7 @@
-import helperCreateIterateHandle from './helperCreateIterateHandle';
-var find = helperCreateIterateHandle('find', 1, 3, true);
-export default find;
+import "../../../chunk-PKUHTIDK.js";
+import helperCreateIterateHandle from "./helperCreateIterateHandle";
+const find = helperCreateIterateHandle("find", 1, 3, true);
+var find_default = find;
+export {
+  find_default as default
+};

package/grid/static/array/findTree.js

@@ -1,39 +1,25 @@
-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;
+import "../../../chunk-PKUHTIDK.js";
+import helperCreateTreeFunc from "./helperCreateTreeFunc";
+const findTreeItem = ({ parent, obj, iterate, context, path, node, parseChildren, 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]);
+    for (let index = 0, len = obj.length; index < len; index++) {
+      const item = obj[index];
+      const paths = path.concat([`${index}`]);
+      const 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
-        };
+        return { index, item, path, items: obj, parent, nodes };
       }
       if (parseChildren && item) {
-        var newPath = paths.concat([parseChildren]);
-        var match = findTreeItem({
+        const newPath = paths.concat([parseChildren]);
+        const match = findTreeItem({
           parent: item,
           obj: item[parseChildren],
-          iterate: iterate,
-          context: context,
+          iterate,
+          context,
           path: newPath,
           node: nodes,
-          parseChildren: parseChildren,
-          opts: opts
+          parseChildren,
+          opts
         });
         if (match) {
           return match;
@@ -42,5 +28,8 @@ var findTreeItem = function findTreeItem(_ref) {
     }
   }
 };
-var findTree = helperCreateTreeFunc(findTreeItem);
-export default findTree;
+const findTree = helperCreateTreeFunc(findTreeItem);
+var findTree_default = findTree;
+export {
+  findTree_default as default
+};

package/grid/static/array/helperCreateIterateHandle.js

@@ -1,15 +1,10 @@
-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;
+import "../../../chunk-PKUHTIDK.js";
+import hasOwnProp from "../base/hasOwnProp";
+const handle = ({ useArray, obj, iterate, context, matchValue, restIndex }) => {
+  let value;
+  let flag = 0;
   if (useArray && Array.isArray(obj)) {
-    for (var index = 0, len = obj.length; index < len; index++) {
+    for (let 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;
@@ -17,8 +12,7 @@ var handle = function handle(_ref) {
       }
     }
   } else {
-    for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
-      var key = _Object$keys[_i];
+    for (let key of Object.keys(obj)) {
       if (hasOwnProp(obj, key)) {
         if (!!iterate.call(context, obj[key], key, obj) === matchValue) {
           value = [true, false, key, obj[key]][restIndex];
@@ -28,32 +22,30 @@ var handle = function handle(_ref) {
       }
     }
   }
-  return {
-    value: value,
-    flag: flag
-  };
+  return { value, 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;
-      }
-    }
+const helperCreateIterateHandle = (prop, useArray, restIndex, matchValue, defaultValue) => (obj, iterate, context) => {
+  if (!obj || !iterate) {
     return defaultValue;
-  };
+  }
+  if (prop && obj[prop]) {
+    return obj[prop](iterate, context);
+  } else {
+    const ret = handle({
+      useArray,
+      obj,
+      iterate,
+      context,
+      matchValue,
+      restIndex
+    });
+    if (ret.flag) {
+      return ret.value;
+    }
+  }
+  return defaultValue;
+};
+var helperCreateIterateHandle_default = helperCreateIterateHandle;
+export {
+  helperCreateIterateHandle_default as default
 };
-export default helperCreateIterateHandle;

package/grid/static/array/helperCreateTreeFunc.js

@@ -1,18 +1,20 @@
-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);
+import "../../../chunk-PKUHTIDK.js";
+const helperCreateTreeFunc = (handle) => (obj, iterate, options, context) => {
+  let opts = options || {};
+  let optChildren = opts.children || "children";
+  const params = {
+    item: null,
+    obj,
+    iterate,
+    context,
+    path: [],
+    node: [],
+    parseChildren: optChildren,
+    opts
   };
+  return handle(params);
+};
+var helperCreateTreeFunc_default = helperCreateTreeFunc;
+export {
+  helperCreateTreeFunc_default as default
 };
-export default helperCreateTreeFunc;

package/grid/static/array/includes.js

@@ -1,5 +1,7 @@
-import indexOf from '../base/indexOf';
-var includes = function includes(obj, val) {
-  return ~indexOf(obj, val);
+import "../../../chunk-PKUHTIDK.js";
+import indexOf from "../base/indexOf";
+const includes = (obj, val) => ~indexOf(obj, val);
+var includes_default = includes;
+export {
+  includes_default as default
 };
-export default includes;

package/grid/static/array/lastArrayEach.js

@@ -1,6 +1,10 @@
-var lastArrayEach = function lastArrayEach(obj, iterate, context) {
-  for (var len = obj.length - 1; len >= 0; len--) {
+import "../../../chunk-PKUHTIDK.js";
+const lastArrayEach = (obj, iterate, context) => {
+  for (let len = obj.length - 1; len >= 0; len--) {
     iterate.call(context, obj[len], len, obj);
   }
 };
-export default lastArrayEach;
+var lastArrayEach_default = lastArrayEach;
+export {
+  lastArrayEach_default as default
+};

package/grid/static/array/map.js

@@ -1,8 +1,9 @@
-import each from '../base/each';
-import isFunction from '../base/isFunction';
-import property from '../function/property';
-var map = function map(obj, iterate, context) {
-  var result = [];
+import "../../../chunk-PKUHTIDK.js";
+import each from "../base/each";
+import isFunction from "../base/isFunction";
+import property from "../function/property";
+const map = function(obj, iterate, context) {
+  let result = [];
   if (obj && arguments.length > 1) {
     if (!isFunction(iterate)) {
       iterate = property(iterate);
@@ -10,14 +11,14 @@ var map = function map(obj, iterate, context) {
     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];
-        }
+      each(obj, (...args) => {
         result.push(iterate.apply(context, args));
       });
     }
   }
   return result;
 };
-export default map;
+var map_default = map;
+export {
+  map_default as default
+};

package/grid/static/array/mapTree.js

@@ -1,33 +1,29 @@
-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);
+import "../../../chunk-PKUHTIDK.js";
+import helperCreateTreeFunc from "./helperCreateTreeFunc";
+import map from "./map";
+const mapTreeItem = ({ parent, obj, iterate, context, path, node, parseChildren, opts }) => {
+  let mapChildren = opts.mapChildren || parseChildren;
+  return map(obj, (item, index) => {
+    const paths = path.concat([`${index}`]);
+    const nodes = node.concat([item]);
+    const rest = iterate.call(context, item, index, obj, paths, parent, nodes);
     if (rest && item && parseChildren && item[parseChildren]) {
       rest[mapChildren] = mapTreeItem({
-        item: item,
+        item,
         obj: item[parseChildren],
-        iterate: iterate,
-        context: context,
+        iterate,
+        context,
         path: paths,
         node: nodes,
-        parseChildren: parseChildren,
-        opts: opts
+        parseChildren,
+        opts
       });
     }
     return rest;
   });
 };
-var mapTree = helperCreateTreeFunc(mapTreeItem);
-export default mapTree;
+const mapTree = helperCreateTreeFunc(mapTreeItem);
+var mapTree_default = mapTree;
+export {
+  mapTree_default as default
+};