@opentiny/vue-renderless 3.1.0-alpha.0

package/grid/static/base/get.js

@@ -0,0 +1,42 @@
+import eqNull from './eqNull';
+import hasOwnProp from './hasOwnProp';
+import isUndefined from './isUndefined';
+import helperGetHGSKeys from './helperGetHGSKeys';
+import staticHGKeyRE from '../static/staticHGKeyRE';
+var valGet = function valGet(obj, key) {
+  var matchs = key ? key.match(staticHGKeyRE) : '';
+  return matchs ? matchs[1] ? obj[matchs[1]] ? obj[matchs[1]][matchs[2]] : undefined : obj[matchs[2]] : obj[key];
+};
+var pathGet = function pathGet(obj, property) {
+  if (!obj) {
+    return;
+  }
+  var rest;
+  var index = 0;
+  var getRest = function 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 {
+    var props = helperGetHGSKeys(property);
+    var len = props.length;
+    if (len) {
+      getRest(len, props);
+    }
+    return rest;
+  }
+};
+var get = function get(obj, property, defaultValue) {
+  if (eqNull(obj)) {
+    return defaultValue;
+  }
+  var result = pathGet(obj, property);
+  return isUndefined(result) ? defaultValue : result;
+};
+export default get;

package/grid/static/base/has.js

@@ -0,0 +1,60 @@
+import hasOwn from './hasOwnProp';
+import staticHGKeyRE from '../static/staticHGKeyRE';
+import helperGetHGSKeys from './helperGetHGSKeys';
+var formatterArgs = function formatterArgs(matchs, rest, isHas) {
+  var arrIndex = matchs[1];
+  var 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: isHas,
+    rest: rest
+  };
+};
+var has = function has(obj, property) {
+  if (!obj) {
+    return;
+  }
+  var compare = function compare(property) {
+    var prop, matchs, rest, isHas;
+    var props = helperGetHGSKeys(property);
+    var index = 0;
+    var len = props.length;
+    var flag = false;
+    for (rest = obj; index < len; index++) {
+      isHas = false;
+      prop = props[index];
+      matchs = prop ? prop.match(staticHGKeyRE) : '';
+      if (matchs) {
+        var 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);
+  }
+};
+export default has;

package/grid/static/base/hasOwnProp.js

@@ -0,0 +1,4 @@
+var hasOwnProp = function hasOwnProp(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+};
+export default hasOwnProp;

package/grid/static/base/helperCreateGetObjects.js

@@ -0,0 +1,26 @@
+import each from './each';
+var helperCreateGetObjects = function helperCreateGetObjects(name, getIndex) {
+  var proMethod = Object[name];
+  return function (obj) {
+    var result = [];
+    if (!obj) {
+      return result;
+    }
+    if (proMethod) {
+      return proMethod(obj);
+    }
+    var eachCallback;
+    if (getIndex > 1) {
+      eachCallback = function eachCallback(key) {
+        result.push(['' + key, obj[key]]);
+      };
+    } else {
+      eachCallback = function eachCallback() {
+        result.push(arguments[getIndex]);
+      };
+    }
+    each(obj, eachCallback);
+    return result;
+  };
+};
+export default helperCreateGetObjects;

package/grid/static/base/helperCreateInInObjectString.js

@@ -0,0 +1,7 @@
+var objectToString = Object.prototype.toString;
+function helperCreateInInObjectString(type) {
+  return function (obj) {
+    return '[object ' + type + ']' === objectToString.call(obj);
+  };
+}
+export default helperCreateInInObjectString;

package/grid/static/base/helperCreateInTypeof.js

@@ -0,0 +1,6 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+export default function helperCreateInTypeof(type) {
+  return function (obj) {
+    return _typeof(obj) === type;
+  };
+}

package/grid/static/base/helperCreateIndexOf.js

@@ -0,0 +1,21 @@
+var helperCreateIndexOf = function helperCreateIndexOf(name, callback) {
+  return function (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 (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      if (val === obj[key]) {
+        return key;
+      }
+    }
+    return -1;
+  };
+};
+export default helperCreateIndexOf;

package/grid/static/base/helperCreateiterateIndexOf.js

@@ -0,0 +1,21 @@
+import isFunction from './isFunction';
+import isString from './isString';
+import hasOwnProp from './hasOwnProp';
+var helperCreateiterateIndexOf = function helperCreateiterateIndexOf(callback) {
+  return function (obj, iterate, context) {
+    if (!obj || !isFunction(iterate)) {
+      return -1;
+    }
+    if (Array.isArray(obj) || isString(obj)) {
+      return callback(obj, iterate, context);
+    }
+    for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      if (hasOwnProp(obj, key) && iterate.call(context, obj[key], key, obj)) {
+        return key;
+      }
+    }
+    return -1;
+  };
+};
+export default helperCreateiterateIndexOf;

package/grid/static/base/helperDefaultCompare.js

@@ -0,0 +1,4 @@
+function helperDefaultCompare(v1, v2) {
+  return v1 === v2;
+}
+export default helperDefaultCompare;

package/grid/static/base/helperDeleteProperty.js

@@ -0,0 +1,8 @@
+var helperDeleteProperty = function helperDeleteProperty(obj, property) {
+  try {
+    delete obj[property];
+  } catch (e) {
+    obj[property] = undefined;
+  }
+};
+export default helperDeleteProperty;

package/grid/static/base/helperEqualCompare.js

@@ -0,0 +1,60 @@
+import { isDate, isRegExp } from '@opentiny/vue-renderless/common/type';
+import isNumber from './isNumber';
+import isString from './isString';
+import isBoolean from './isBoolean';
+import isUndefined from './isUndefined';
+import keys from './keys';
+import every from '../array/every';
+var equalVal;
+var helperEqualCompare = function helperEqualCompare(_ref) {
+  var val1 = _ref.val1,
+    val2 = _ref.val2,
+    compare = _ref.compare,
+    func = _ref.func,
+    key = _ref.key,
+    obj1 = _ref.obj1,
+    obj2 = _ref.obj2;
+  if (val1 === val2) {
+    return true;
+  }
+  if (val1 && val2 && !isNumber(val1) && !isNumber(val2) && !isString(val1) && !isString(val2)) {
+    if (isRegExp(val1)) {
+      return compare('' + val1, '' + val2, key, obj1, obj2);
+    }
+    if (isDate(val1) || isBoolean(val1)) {
+      return compare(+val1, +val2, key, obj1, obj2);
+    }
+    return equalVal(val1, val2, func, key, compare);
+  }
+  return compare(val1, val2, key, obj1, obj2);
+};
+equalVal = function equalVal(val1, val2, func, key, compare) {
+  var result, val1Keys, val2Keys;
+  var isObj1Arr = Array.isArray(val1);
+  var isObj2Arr = Array.isArray(val2);
+  if (isObj1Arr || isObj2Arr ? isObj1Arr && isObj2Arr : val1.constructor === val2.constructor) {
+    val1Keys = keys(val1);
+    val2Keys = keys(val2);
+    if (func) {
+      result = func(val1, val2, key);
+    }
+    if (val1Keys.length === val2Keys.length) {
+      if (isUndefined(result)) {
+        return every(val1Keys, function (key, index) {
+          return key === val2Keys[index] && helperEqualCompare({
+            val1: val1[key],
+            val2: val2[val2Keys[index]],
+            compare: compare,
+            func: func,
+            key: isObj1Arr || isObj2Arr ? index : key,
+            obj1: val1,
+            obj2: val2
+          });
+        });
+      }
+      return !!result;
+    }
+    return false;
+  }
+};
+export default helperEqualCompare;

package/grid/static/base/helperGetHGSKeys.js

@@ -0,0 +1,4 @@
+var helperGetHGSKeys = function helperGetHGSKeys(property) {
+  return property ? property.splice && property.join ? property : ('' + property).split('.') : [];
+};
+export default helperGetHGSKeys;

package/grid/static/base/indexOf.js

@@ -0,0 +1,3 @@
+import helperCreateIndexOfFn from './helperCreateIndexOf';
+import arrayIndexOfFn from '../array/arrayIndexOf';
+export default helperCreateIndexOfFn('indexOf', arrayIndexOfFn);

package/grid/static/base/isArray.js

@@ -0,0 +1,3 @@
+import helperCreateInInObjectString from './helperCreateInInObjectString';
+var isArray = Array.isArray || helperCreateInInObjectString('Array');
+export default isArray;

package/grid/static/base/isBoolean.js

@@ -0,0 +1,4 @@
+var isBoolean = function isBoolean(obj) {
+  return typeof obj === 'boolean';
+};
+export default isBoolean;

package/grid/static/base/isDate.js

@@ -0,0 +1,3 @@
+import helperCreateInInObjectString from './helperCreateInInObjectString';
+var isDate = helperCreateInInObjectString('Date');
+export default isDate;

package/grid/static/base/isEmpty.js

@@ -0,0 +1,8 @@
+import isObject from './isObject';
+var isEmpty = function isEmpty(obj) {
+  if (isObject(obj)) {
+    return Object.keys(obj).length === 0;
+  }
+  return true;
+};
+export default isEmpty;

package/grid/static/base/isEqual.js

@@ -0,0 +1,11 @@
+import helperEqlCompare from './helperEqualCompare';
+var isEqual = function isEqual(obj1, obj2) {
+  return helperEqlCompare({
+    val1: obj1,
+    val2: obj2,
+    compare: function compare(v1, v2) {
+      return v1 === v2;
+    }
+  });
+};
+export default isEqual;

package/grid/static/base/isFunction.js

@@ -0,0 +1,4 @@
+var isFunction = function isFunction(obj) {
+  return typeof obj === 'function';
+};
+export default isFunction;

package/grid/static/base/isNaN.js

@@ -0,0 +1,5 @@
+import isNumber from './isNumber';
+var isNumberNaN = function isNumberNaN(obj) {
+  return isNumber(obj) && isNaN(obj);
+};
+export default isNumberNaN;

package/grid/static/base/isNull.js

@@ -0,0 +1,4 @@
+var isNull = function isNull(object) {
+  return object === null;
+};
+export default isNull;

package/grid/static/base/isNumber.js

@@ -0,0 +1,4 @@
+var isNumber = function isNumber(obj) {
+  return typeof obj === 'number';
+};
+export default isNumber;

package/grid/static/base/isObject.js

@@ -0,0 +1,5 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+var isObject = function isObject(obj) {
+  return _typeof(obj) === 'object' && obj !== null;
+};
+export default isObject;

package/grid/static/base/isPlainObject.js

@@ -0,0 +1,2 @@
+import { isPlainObject } from '@opentiny/vue-renderless/common/type';
+export default isPlainObject;

package/grid/static/base/isRegExp.js

@@ -0,0 +1,3 @@
+import helperCreateInInObjectString from './helperCreateInInObjectString';
+var isRegExp = helperCreateInInObjectString('RegExp');
+export default isRegExp;

package/grid/static/base/isSet.js

@@ -0,0 +1,5 @@
+var supportSet = typeof Set !== 'undefined';
+var isSet = function isSet(obj) {
+  return supportSet && obj instanceof Set;
+};
+export default isSet;

package/grid/static/base/isString.js

@@ -0,0 +1,4 @@
+var isString = function isString(obj) {
+  return typeof obj === 'string';
+};
+export default isString;

package/grid/static/base/isUndefined.js

@@ -0,0 +1,4 @@
+var isUndefined = function isUndefined(obj) {
+  return typeof obj === 'undefined';
+};
+export default isUndefined;

package/grid/static/base/keys.js

@@ -0,0 +1,3 @@
+import helperCreateGetObjects from './helperCreateGetObjects';
+var keys = helperCreateGetObjects('keys', 1);
+export default keys;

package/grid/static/base/lastEach.js

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

package/grid/static/base/remove.js

@@ -0,0 +1,44 @@
+import helperDeleteProperty from './helperDeleteProperty';
+import isFunction from './isFunction';
+import each from './each';
+import arrayEach from '../array/arrayEach';
+import lastEach from './lastEach';
+import clear from './clear';
+import eqNull from './eqNull';
+var pluckProperty = function pluckProperty(name) {
+  return function (obj, key) {
+    return key === name;
+  };
+};
+var remove = function remove(obj, iterate, context) {
+  if (obj) {
+    if (!eqNull(iterate)) {
+      var removeIndexs = [];
+      var rest = [];
+      if (!isFunction(iterate)) {
+        iterate = pluckProperty(iterate);
+      }
+      each(obj, function (item, index, rest) {
+        if (iterate.call(context, item, index, rest)) {
+          removeIndexs.push(index);
+        }
+      });
+      if (Array.isArray(obj)) {
+        lastEach(removeIndexs, function (item) {
+          rest.push(obj[item]);
+          obj.splice(item, 1);
+        });
+      } else {
+        rest = {};
+        arrayEach(removeIndexs, function (key) {
+          rest[key] = obj[key];
+          helperDeleteProperty(obj, key);
+        });
+      }
+      return rest;
+    }
+    return clear(obj);
+  }
+  return obj;
+};
+export default remove;

package/grid/static/base/set.js

@@ -0,0 +1,43 @@
+import helperGetHGSKeys from './helperGetHGSKeys';
+import hasOwn from './hasOwnProp';
+var sKeyRE = /(.+)\[(\d+)\]$/;
+var valSet = function valSet(obj, key, isSet, value) {
+  if (obj[key]) {
+    if (isSet) {
+      obj[key] = value;
+    }
+  } else {
+    var matchs = key ? key.match(sKeyRE) : null;
+    var rest = isSet ? value : {};
+    if (matchs) {
+      var _key = matchs[1];
+      var index = parseInt(matchs[2]);
+      if (obj[_key]) {
+        obj[_key][index] = rest;
+      } else {
+        obj[_key] = new Array(index + 1);
+        obj[_key][index] = rest;
+      }
+    } else {
+      obj[key] = rest;
+    }
+    return rest;
+  }
+  return obj[key];
+};
+var set = function set(obj, property, value) {
+  if (obj) {
+    if (obj[property] || hasOwn(obj, property)) {
+      obj[property] = value;
+    } else {
+      var rest = obj;
+      var props = helperGetHGSKeys(property);
+      var len = props.length;
+      for (var index = 0; index < len; index++) {
+        rest = valSet(rest, props[index], index === len - 1, value);
+      }
+    }
+  }
+  return obj;
+};
+export default set;

package/grid/static/base/toJSONString.js

@@ -0,0 +1,4 @@
+var toJSONString = function toJSONString(obj) {
+  return JSON.stringify(obj) || '';
+};
+export default toJSONString;

package/grid/static/base/toStringJSON.js

@@ -0,0 +1,13 @@
+import isObject from './isObject';
+import isString from './isString';
+var toStringJSON = function toStringJSON(str) {
+  if (isObject(str)) {
+    return str;
+  } else if (isString(str)) {
+    try {
+      return JSON.parse(str);
+    } catch (error) {}
+  }
+  return {};
+};
+export default toStringJSON;

package/grid/static/base/uniqueId.js

@@ -0,0 +1,5 @@
+var __uniqueId = 0;
+var uniqueId = function uniqueId(prefix) {
+  return (prefix ? '' + prefix : 0) + ++__uniqueId;
+};
+export default uniqueId;

package/grid/static/browse/browse.js

@@ -0,0 +1,54 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import staticStrUndefined from '../static/staticStrUndefined';
+import staticDocument from '../static/staticDocument';
+import staticWindow from '../static/staticWindow';
+import assign from '../object/assign';
+import arrayEach from '../array/arrayEach';
+function isBrowseStorage(storage) {
+  try {
+    var testKey = '__tiny_t';
+    storage.setItem(testKey, 1);
+    storage.removeItem(testKey);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isBrowseType(type) {
+  return navigator.userAgent.indexOf(type) > -1;
+}
+function browse() {
+  var $body, isChrome, isEdge;
+  var isMobile = false;
+  var result = {
+    isNode: false,
+    isMobile: isMobile,
+    isPC: false,
+    isDoc: !!staticDocument
+  };
+  if (!staticWindow && (typeof process === "undefined" ? "undefined" : _typeof(process)) !== staticStrUndefined) {
+    result.isNode = true;
+  } else {
+    isEdge = isBrowseType('Edge');
+    isChrome = isBrowseType('Chrome');
+    isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+    if (result.isDoc) {
+      $body = staticDocument.body || staticDocument.documentElement;
+      arrayEach(['webkit', 'khtml', 'moz', 'ms', 'o'], function (core) {
+        result['-' + core] = !!$body[core + 'MatchesSelector'];
+      });
+    }
+    assign(result, {
+      edge: isEdge,
+      firefox: isBrowseType('Firefox'),
+      msie: !isEdge && result['-ms'],
+      safari: !isChrome && !isEdge && isBrowseType('Safari'),
+      isMobile: isMobile,
+      isPC: !isMobile,
+      isLocalStorage: isBrowseStorage(staticWindow.localStorage),
+      isSessionStorage: isBrowseStorage(staticWindow.sessionStorage)
+    });
+  }
+  return result;
+}
+export default browse;

package/grid/static/function/property.js

@@ -0,0 +1,7 @@
+import isNull from '../base/isNull';
+var property = function property(key, defs) {
+  return function (object) {
+    return isNull(object) ? defs : object[key];
+  };
+};
+export default property;

package/grid/static/function/throttle.js

@@ -0,0 +1,43 @@
+function throttle(callback, wait, options) {
+  var args;
+  var context;
+  var ops = options || {};
+  var flag = false;
+  var timeout = 0;
+  var optLeading = 'leading' in ops ? ops.leading : true;
+  var optTrailing = 'trailing' in ops ? ops.trailing : false;
+  var endFn;
+  var runFn = function runFn() {
+    flag = true;
+    callback.apply(context, args);
+    timeout = setTimeout(endFn, wait);
+  };
+  endFn = function endFn() {
+    timeout = 0;
+    if (!flag && optTrailing === true) {
+      runFn();
+    }
+  };
+  var cancelFn = function cancelFn() {
+    var rest = timeout !== 0;
+    clearTimeout(timeout);
+    flag = false;
+    timeout = 0;
+    return rest;
+  };
+  var throttled = function throttled() {
+    args = arguments;
+    context = this;
+    flag = false;
+    if (timeout === 0) {
+      if (optLeading === true) {
+        runFn();
+      } else if (optTrailing === true) {
+        timeout = setTimeout(endFn, wait);
+      }
+    }
+  };
+  throttled.cancel = cancelFn;
+  return throttled;
+}
+export default throttle;