@opentinyvue/vue-renderless 3.21.0

package/grid/static/array/filterTree.js

@@ -0,0 +1,21 @@
+import "../../../chunk-G2ADBYYC.js";
+import eachTree from "./eachTree";
+const filterTree = (obj, iterate, options, context) => {
+  let result = [];
+  if (obj && iterate) {
+    eachTree(
+      obj,
+      (...args) => {
+        if (iterate.apply(context, args)) {
+          result.push(args[0]);
+        }
+      },
+      options
+    );
+  }
+  return result;
+};
+var filterTree_default = filterTree;
+export {
+  filterTree_default as default
+};

package/grid/static/array/find.js

@@ -0,0 +1,7 @@
+import "../../../chunk-G2ADBYYC.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

@@ -0,0 +1,35 @@
+import "../../../chunk-G2ADBYYC.js";
+import helperCreateTreeFunc from "./helperCreateTreeFunc";
+const findTreeItem = ({ parent, obj, iterate, context, path, node, parseChildren, opts }) => {
+  if (obj) {
+    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, item, path, items: obj, parent, nodes };
+      }
+      if (parseChildren && item) {
+        const newPath = paths.concat([parseChildren]);
+        const match = findTreeItem({
+          parent: item,
+          obj: item[parseChildren],
+          iterate,
+          context,
+          path: newPath,
+          node: nodes,
+          parseChildren,
+          opts
+        });
+        if (match) {
+          return match;
+        }
+      }
+    }
+  }
+};
+const findTree = helperCreateTreeFunc(findTreeItem);
+var findTree_default = findTree;
+export {
+  findTree_default as default
+};

package/grid/static/array/helperCreateIterateHandle.js

@@ -0,0 +1,51 @@
+import "../../../chunk-G2ADBYYC.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 (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;
+        break;
+      }
+    }
+  } else {
+    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];
+          flag = 2;
+          break;
+        }
+      }
+    }
+  }
+  return { value, flag };
+};
+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
+};

package/grid/static/array/helperCreateTreeFunc.js

@@ -0,0 +1,20 @@
+import "../../../chunk-G2ADBYYC.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
+};

package/grid/static/array/includes.js

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

package/grid/static/array/lastArrayEach.js

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

package/grid/static/array/map.js

@@ -0,0 +1,24 @@
+import "../../../chunk-G2ADBYYC.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);
+    }
+    if (obj.map) {
+      return obj.map(iterate, context);
+    } else {
+      each(obj, (...args) => {
+        result.push(iterate.apply(context, args));
+      });
+    }
+  }
+  return result;
+};
+var map_default = map;
+export {
+  map_default as default
+};

package/grid/static/array/mapTree.js

@@ -0,0 +1,29 @@
+import "../../../chunk-G2ADBYYC.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,
+        obj: item[parseChildren],
+        iterate,
+        context,
+        path: paths,
+        node: nodes,
+        parseChildren,
+        opts
+      });
+    }
+    return rest;
+  });
+};
+const mapTree = helperCreateTreeFunc(mapTreeItem);
+var mapTree_default = mapTree;
+export {
+  mapTree_default as default
+};

package/grid/static/array/slice.js

@@ -0,0 +1,14 @@
+import "../../../chunk-G2ADBYYC.js";
+const slice = (array, startIndex, endIndex) => {
+  let result = [];
+  if (array) {
+    for (startIndex = startIndex || 0, endIndex = endIndex || array.length; startIndex < endIndex; startIndex++) {
+      result.push(array[startIndex]);
+    }
+  }
+  return result;
+};
+var slice_default = slice;
+export {
+  slice_default as default
+};

package/grid/static/array/sortBy.js

@@ -0,0 +1,67 @@
+import "../../../chunk-G2ADBYYC.js";
+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";
+const 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;
+};
+const sortMultis = (name, compares) => (item1, item2) => {
+  let v1 = item1[name];
+  let v2 = item2[name];
+  if (v1 === v2) {
+    return compares ? compares(item1, item2) : 0;
+  }
+  return sortByDef(v1, v2);
+};
+const getSortPros = (arr, list, iterate, context) => {
+  iterate = Array.isArray(iterate) ? iterate : [iterate];
+  arrayEach(iterate, (prop, index) => {
+    let eachCallback;
+    if (isFunction(prop)) {
+      eachCallback = (val, key) => {
+        val[index] = prop.call(context, val.data, key, arr);
+      };
+    } else {
+      eachCallback = (val) => {
+        val[index] = get(val.data, prop);
+      };
+    }
+    arrayEach(list, eachCallback);
+  });
+  return iterate;
+};
+const sortBy = (arr, iterate, context, STR_UNDEFINED) => {
+  if (arr) {
+    if (iterate === STR_UNDEFINED) {
+      return toArray(arr).sort(sortByDef);
+    }
+    let compares;
+    let list = map(arr, (item) => ({ data: item }));
+    let sortPros = getSortPros(arr, list, iterate, context);
+    let len = sortPros.length;
+    if (len) {
+      while (len >= 0) {
+        compares = sortMultis(len, compares);
+        len--;
+      }
+      list = list.sort(compares);
+    }
+    return map(list, property("data"));
+  }
+  return [];
+};
+var sortBy_default = sortBy;
+export {
+  sortBy_default as default
+};

package/grid/static/array/sum.js

@@ -0,0 +1,29 @@
+import "../../../chunk-G2ADBYYC.js";
+import each from "../base/each";
+import isFunction from "../base/isFunction";
+import toNumber from "../number/toNumber";
+const sum = (array, iterate, context) => {
+  let result = 0;
+  let eachCallback;
+  if (iterate) {
+    if (isFunction(iterate)) {
+      eachCallback = (...args) => {
+        result += toNumber(iterate.apply(context, args));
+      };
+    } else {
+      eachCallback = (val) => {
+        result += toNumber(val[iterate]);
+      };
+    }
+  } else {
+    eachCallback = (val) => {
+      result += toNumber(val);
+    };
+  }
+  each(array, eachCallback);
+  return result;
+};
+var sum_default = sum;
+export {
+  sum_default as default
+};

package/grid/static/array/toArray.js

@@ -0,0 +1,7 @@
+import "../../../chunk-G2ADBYYC.js";
+import map from "./map";
+const toArray = (arr) => map(arr, (item) => item);
+var toArray_default = toArray;
+export {
+  toArray_default as default
+};

package/grid/static/array/toTreeArray.js

@@ -0,0 +1,22 @@
+import "../../../chunk-G2ADBYYC.js";
+import each from "../base/each";
+import assign from "../object/assign";
+const defaultOptions = { parentKey: "parentId", key: "id", children: "children" };
+const unTreeList = (result, array, opts) => {
+  let optChildren = opts.children;
+  let optData = opts.data;
+  each(array, (item) => {
+    const children = item[optChildren];
+    if (optData) {
+      item = item[optData];
+    }
+    result.push(item);
+    children && unTreeList(result, children, opts);
+  });
+  return result;
+};
+const toTreeArray = (array, options) => unTreeList([], array, assign({}, defaultOptions, options));
+var toTreeArray_default = toTreeArray;
+export {
+  toTreeArray_default as default
+};

package/grid/static/base/clear.js

@@ -0,0 +1,48 @@
+import "../../../chunk-G2ADBYYC.js";
+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";
+const clear = function(obj, defs, assigns) {
+  if (!obj) {
+    return obj;
+  }
+  let isDefs = arguments.length > 1 && (isNull(defs) || !isObject(defs));
+  let extds = isDefs ? assigns : defs;
+  if (isPlainObject(obj)) {
+    let eachCallback;
+    if (isDefs) {
+      eachCallback = (val, key) => {
+        obj[key] = defs;
+      };
+    } else {
+      eachCallback = (val, key) => {
+        helperDeleteProperty(obj, key);
+      };
+    }
+    objectEach(obj, eachCallback);
+    if (extds) {
+      assign(obj, extds);
+    }
+  } else if (Array.isArray(obj)) {
+    if (isDefs) {
+      let len = obj.length;
+      while (len > 0) {
+        len--;
+        obj[len] = defs;
+      }
+    } else {
+      obj.length = 0;
+    }
+    if (extds) {
+      obj.push.apply(obj, extds);
+    }
+  }
+  return obj;
+};
+var clear_default = clear;
+export {
+  clear_default as default
+};

package/grid/static/base/clone.js

@@ -0,0 +1,12 @@
+import "../../../chunk-G2ADBYYC.js";
+import isPlainObject from "./isPlainObject";
+import objectMap from "../object/objectMap";
+import map from "../array/map";
+let deepClone;
+const startClone = (func, obj, deep) => func(obj, deep ? (val) => deepClone(val, deep) : (val) => val);
+deepClone = (val, deep) => isPlainObject(val) ? startClone(objectMap, val, deep) : Array.isArray(val) ? startClone(map, val, deep) : val;
+const clone = (obj, deep) => obj ? deepClone(obj, deep) : obj;
+var clone_default = clone;
+export {
+  clone_default as default
+};

package/grid/static/base/destructuring.js

@@ -0,0 +1,22 @@
+import "../../../chunk-G2ADBYYC.js";
+import keys from "./keys";
+import slice from "../array/slice";
+import assign from "../object/assign";
+import includes from "../array/includes";
+import arrayEach from "../array/arrayEach";
+const destructuring = function(destination, sources) {
+  if (destination && sources) {
+    let rest = assign.apply(this, [{}].concat(slice(arguments, 1)));
+    let restKeys = keys(rest);
+    arrayEach(keys(destination), (key) => {
+      if (includes(restKeys, key)) {
+        destination[key] = rest[key];
+      }
+    });
+  }
+  return destination;
+};
+var destructuring_default = destructuring;
+export {
+  destructuring_default as default
+};

package/grid/static/base/each.js

@@ -0,0 +1,13 @@
+import "../../../chunk-G2ADBYYC.js";
+import arrayEach from "../array/arrayEach";
+import objectEach from "../object/objectEach";
+const each = (obj, iterate, context) => {
+  if (obj) {
+    return Array.isArray(obj) ? arrayEach(obj, iterate, context) : objectEach(obj, iterate, context);
+  }
+  return obj;
+};
+var each_default = each;
+export {
+  each_default as default
+};

package/grid/static/base/eqNull.js

@@ -0,0 +1,8 @@
+import "../../../chunk-G2ADBYYC.js";
+import isNullType from "./isNull";
+import isUndefinedType from "./isUndefined";
+const eqNull = (object) => isNullType(object) || isUndefinedType(object);
+var eqNull_default = eqNull;
+export {
+  eqNull_default as default
+};

package/grid/static/base/findIndexOf.js

@@ -0,0 +1,14 @@
+import "../../../chunk-G2ADBYYC.js";
+import helperCreateiterateIndexOf from "./helperCreateiterateIndexOf";
+const findIndexOf = helperCreateiterateIndexOf((obj, iterate, context) => {
+  for (let index = 0, len = obj.length; index < len; index++) {
+    if (iterate.call(context, obj[index], index, obj)) {
+      return index;
+    }
+  }
+  return -1;
+});
+var findIndexOf_default = findIndexOf;
+export {
+  findIndexOf_default as default
+};

package/grid/static/base/get.js

@@ -0,0 +1,46 @@
+import "../../../chunk-G2ADBYYC.js";
+import eqNull from "./eqNull";
+import hasOwnProp from "./hasOwnProp";
+import isUndefined from "./isUndefined";
+import helperGetHGSKeys from "./helperGetHGSKeys";
+import staticHGKeyRE from "../static/staticHGKeyRE";
+const valGet = (obj, key) => {
+  const matchs = key ? key.match(staticHGKeyRE) : "";
+  return matchs ? matchs[1] ? obj[matchs[1]] ? obj[matchs[1]][matchs[2]] : void 0 : obj[matchs[2]] : obj[key];
+};
+const pathGet = (obj, property) => {
+  if (!obj) {
+    return;
+  }
+  let rest;
+  let index = 0;
+  const getRest = (len, props) => {
+    for (rest = obj; index < len; index++) {
+      rest = valGet(rest, props[index]);
+      if (eqNull(rest)) {
+        return;
+      }
+    }
+  };
+  if (obj[property] || hasOwnProp(obj, property)) {
+    return obj[property];
+  } else {
+    const props = helperGetHGSKeys(property);
+    const len = props.length;
+    if (len) {
+      getRest(len, props);
+    }
+    return rest;
+  }
+};
+const get = (obj, property, defaultValue) => {
+  if (eqNull(obj)) {
+    return defaultValue;
+  }
+  const result = pathGet(obj, property);
+  return isUndefined(result) ? defaultValue : result;
+};
+var get_default = get;
+export {
+  get_default as default
+};

package/grid/static/base/has.js

@@ -0,0 +1,61 @@
+import "../../../chunk-G2ADBYYC.js";
+import hasOwn from "./hasOwnProp";
+import staticHGKeyRE from "../static/staticHGKeyRE";
+import helperGetHGSKeys from "./helperGetHGSKeys";
+const formatterArgs = (matchs, rest, isHas) => {
+  let arrIndex = matchs[1];
+  let objProp = matchs[2];
+  if (arrIndex) {
+    if (rest[arrIndex]) {
+      if (hasOwn(rest[arrIndex], objProp)) {
+        isHas = true;
+        rest = rest[arrIndex][objProp];
+      }
+    }
+  } else {
+    if (hasOwn(rest, objProp)) {
+      isHas = true;
+      rest = rest[objProp];
+    }
+  }
+  return { isHas, rest };
+};
+const has = (obj, property) => {
+  if (!obj) {
+    return;
+  }
+  const compare = (property2) => {
+    let prop, matchs, rest, isHas;
+    let props = helperGetHGSKeys(property2);
+    let index = 0;
+    let len = props.length;
+    let flag = false;
+    for (rest = obj; index < len; index++) {
+      isHas = false;
+      prop = props[index];
+      matchs = prop ? prop.match(staticHGKeyRE) : "";
+      if (matchs) {
+        const args = formatterArgs(matchs, rest, isHas);
+        isHas = args.isHas;
+        rest = args.rest;
+      } else {
+        hasOwn(rest, prop) && (isHas = true, rest = rest[prop]);
+      }
+      if (isHas) {
+        index === len - 1 && (flag = true);
+      } else {
+        break;
+      }
+    }
+    return flag;
+  };
+  if (hasOwn(obj, property)) {
+    return true;
+  } else {
+    return compare(property);
+  }
+};
+var has_default = has;
+export {
+  has_default as default
+};

package/grid/static/base/hasOwnProp.js

@@ -0,0 +1,6 @@
+import "../../../chunk-G2ADBYYC.js";
+const hasOwnProp = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var hasOwnProp_default = hasOwnProp;
+export {
+  hasOwnProp_default as default
+};

package/grid/static/base/helperCreateGetObjects.js

@@ -0,0 +1,30 @@
+import "../../../chunk-G2ADBYYC.js";
+import each from "./each";
+const helperCreateGetObjects = (name, getIndex) => {
+  let proMethod = Object[name];
+  return (obj) => {
+    let result = [];
+    if (!obj) {
+      return result;
+    }
+    if (proMethod) {
+      return proMethod(obj);
+    }
+    let eachCallback;
+    if (getIndex > 1) {
+      eachCallback = (key) => {
+        result.push([String(key), obj[key]]);
+      };
+    } else {
+      eachCallback = function() {
+        result.push(arguments[getIndex]);
+      };
+    }
+    each(obj, eachCallback);
+    return result;
+  };
+};
+var helperCreateGetObjects_default = helperCreateGetObjects;
+export {
+  helperCreateGetObjects_default as default
+};

package/grid/static/base/helperCreateInInObjectString.js

@@ -0,0 +1,11 @@
+import "../../../chunk-G2ADBYYC.js";
+let objectToString = Object.prototype.toString;
+function helperCreateInInObjectString(type) {
+  return function(obj) {
+    return "[object " + type + "]" === objectToString.call(obj);
+  };
+}
+var helperCreateInInObjectString_default = helperCreateInInObjectString;
+export {
+  helperCreateInInObjectString_default as default
+};

package/grid/static/base/helperCreateInTypeof.js

@@ -0,0 +1,9 @@
+import "../../../chunk-G2ADBYYC.js";
+function helperCreateInTypeof(type) {
+  return function(obj) {
+    return typeof obj === type;
+  };
+}
+export {
+  helperCreateInTypeof as default
+};

package/grid/static/base/helperCreateIndexOf.js

@@ -0,0 +1,22 @@
+import "../../../chunk-G2ADBYYC.js";
+const helperCreateIndexOf = (name, callback) => (obj, val) => {
+  if (!obj) {
+    return -1;
+  }
+  if (typeof obj === "string" || Array.isArray(obj)) {
+    if (obj[name]) {
+      return obj[name](val);
+    }
+    return callback(obj, val);
+  }
+  for (let key of Object.keys(obj)) {
+    if (val === obj[key]) {
+      return key;
+    }
+  }
+  return -1;
+};
+var helperCreateIndexOf_default = helperCreateIndexOf;
+export {
+  helperCreateIndexOf_default as default
+};