@opentiny/vue-renderless 3.1.0-alpha.0

package/common/date.js

@@ -0,0 +1,352 @@
+import { isDate, isNumber, isNumeric } from '@opentiny/vue-renderless/common/type';
+import { fillChar } from '@opentiny/vue-renderless/common/string';
+var daysInMonths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var yyyymmddReg = new RegExp('^(\\d{4})(/|-)(((0)?[1-9])|(1[0-2]))((/|-)(((0)?[1-9])|([1-2][0-9])|(3[0-1])))' + '?( ((0)?[0-9]|1[0-9]|20|21|22|23):([0-5]?[0-9])((:([0-5]?[0-9]))?(.([0-9]{1,6}))?)?)?$');
+var mmddyyyyReg = new RegExp('^(((0)?[1-9])|(1[0-2]))(/|-)(((0)?[1-9])|([1-2][0-9])|(3[0-1]))?(/|-)?(\\d{4})' + '( ((0)?[0-9]|1[0-9]|20|21|22|23):([0-5]?[0-9])((:([0-5]?[0-9]))?(.([0-9]{1,6}))?)?)?$');
+var iso8601Reg = new RegExp('^(\\d{4})-(((0)?[1-9])|(1[0-2]))-(((0)?[1-9])|([1-2][0-9])|(3[0-1]))T' + '(((0)?[0-9]|1[0-9]|20|21|22|23):([0-5]?[0-9])((:([0-5]?[0-9]))?(.([0-9]{1,6}))?)?)?(Z|([+-])' + '((0)?[0-9]|1[0-9]|20|21|22|23):?([0-5]?[0-9]))$');
+var dateFormatRegs = {
+  'y{1,4}': /y{1,4}/,
+  'M{1,2}': /M{1,2}/,
+  'd{1,2}': /d{1,2}/,
+  'h{1,2}': /h{1,2}/,
+  'm{1,2}': /m{1,2}/,
+  's{1,2}': /s{1,2}/,
+  'S{1,3}': /S{1,3}/,
+  'Z{1,1}': /Z{1,1}/
+};
+var maxDateValues = {
+  YEAR: 9999,
+  MONTH: 11,
+  DATE: 31,
+  HOUR: 23,
+  MINUTE: 59,
+  SECOND: 59,
+  MILLISECOND: 999
+};
+var timezone1 = '-12:00,-11:00,-10:00,-09:30,-08:00,-07:00,-06:00,-05:00,-04:30,-04:00,-03:30,-02:00,-01:00';
+var timezone2 = '-00:00,+00:00,+01:00,+02:00,+03:00,+03:30,+04:00,+04:30,+05:00,+05:30,+05:45,+06:00';
+var timezone3 = '+06:30,+07:00,+08:00,+09:00,+10:00,+10:30,+11:00,+11:30,+12:00,+12:45,+13:00,+14:00';
+var timezones = [].concat(timezone1.split(','), timezone2.split(','), timezone3.split(','));
+var getTimezone = function getTimezone(date) {
+  var timezoneoffset = 0 - date.getTimezoneOffset() / 60;
+  var timezone;
+  if (timezoneoffset === 0) {
+    timezone = 'Z';
+  } else if (timezoneoffset > 0) {
+    timezone = '+' + (timezoneoffset > 10 ? timezoneoffset : '0' + timezoneoffset) + '00';
+  } else {
+    timezone = (timezoneoffset < -10 ? timezoneoffset : '-0' + -timezoneoffset) + '00';
+  }
+  return timezone;
+};
+export var isLeapYear = function isLeapYear(year) {
+  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+};
+var getDateFromData = function getDateFromData(_ref) {
+  var year = _ref.year,
+    month = _ref.month,
+    date = _ref.date,
+    hours = _ref.hours,
+    minutes = _ref.minutes,
+    seconds = _ref.seconds,
+    milliseconds = _ref.milliseconds;
+  var daysInMonth = daysInMonths[month];
+  if (isLeapYear(year) && month === 1) {
+    daysInMonth += 1;
+  }
+  if (date <= daysInMonth) {
+    return new Date(year, month, date, hours, minutes, seconds, milliseconds);
+  }
+};
+var yyyymmddDateParser = function yyyymmddDateParser(m) {
+  if (m.length === 23) {
+    var year = m[1] * 1;
+    var month = m[3] - 1;
+    var date = (m[9] || 1) * 1;
+    var hours = m[15] || 0;
+    var minutes = m[17] || 0;
+    var seconds = m[20] || 0;
+    var milliseconds = m[22] || 0;
+    return getDateFromData({
+      date: date,
+      year: year,
+      hours: hours,
+      month: month,
+      seconds: seconds,
+      minutes: minutes,
+      milliseconds: milliseconds
+    });
+  }
+};
+var mmddyyyyDateParser = function mmddyyyyDateParser(m) {
+  if (m.length === 22) {
+    var year = m[12] * 1;
+    var month = m[1] - 1;
+    var date = (m[6] || 1) * 1;
+    var hours = m[14] || 0;
+    var minutes = m[16] || 0;
+    var seconds = m[19] || 0;
+    var milliseconds = m[21] || 0;
+    return getDateFromData({
+      year: year,
+      month: month,
+      date: date,
+      hours: hours,
+      minutes: minutes,
+      seconds: seconds,
+      milliseconds: milliseconds
+    });
+  }
+};
+var iso8601DateParser = function iso8601DateParser(m) {
+  if (m.length !== 25) {
+    return;
+  }
+  var year = m[1] * 1;
+  var month = m[2] - 1;
+  var date = m[6] * 1;
+  var offset = new Date(year, month, date).getTimezoneOffset();
+  var hours = m[12] || 0;
+  var minutes = m[14] || 0;
+  var seconds = m[17] || 0;
+  var milliseconds = m[19] || 0;
+  var timeZone = m[20];
+  var sign = m[21];
+  var offsetHours = m[22] || 0;
+  var offsetMinutes = m[24] || 0;
+  var daysInMonth = daysInMonths[month];
+  var actHours;
+  var actMinutes;
+  if (isLeapYear(year) && month === 1) {
+    daysInMonth += 1;
+  }
+  if (date <= daysInMonth) {
+    if (timeZone === 'Z') {
+      actHours = hours - offset / 60;
+      actMinutes = minutes;
+    } else {
+      if (timeZone.indexOf(':') === -1) {
+        timeZone = timeZone.substr(0, 3) + ':' + timeZone.substr(3);
+      }
+      if (timezones.indexOf(timeZone) === -1) {
+        return;
+      }
+      actHours = sign === '+' ? hours - offsetHours - offset / 60 : hours * 1 + offsetHours * 1 - offset / 60;
+      actMinutes = sign === '+' ? minutes - offsetMinutes : minutes * 1 + offsetMinutes * 1;
+    }
+    return new Date(year, month, date, actHours, actMinutes, seconds, milliseconds);
+  }
+};
+var dateParsers = [[yyyymmddReg, yyyymmddDateParser], [mmddyyyyReg, mmddyyyyDateParser], [iso8601Reg, iso8601DateParser]];
+var parseDate = function parseDate(str) {
+  for (var i = 0, len = dateParsers.length; i < len; i++) {
+    var m = dateParsers[i][0].exec(str);
+    if (m && m.length > 0) {
+      return dateParsers[i][1](m);
+    }
+  }
+};
+var matchDateArray = function matchDateArray(arr, value, text) {
+  if (text) {
+    switch (text) {
+      case 'yyyy':
+      case 'yy':
+        arr[0] = value;
+        break;
+      case 'M':
+      case 'MM':
+        arr[1] = value - 1;
+        break;
+      case 'd':
+      case 'dd':
+        arr[2] = value;
+        break;
+      case 'h':
+      case 'hh':
+        arr[3] = value;
+        break;
+      case 'm':
+      case 'mm':
+        arr[4] = value;
+        break;
+      case 's':
+      case 'ss':
+        arr[5] = value;
+        break;
+      case 'S':
+      case 'SS':
+      case 'SSS':
+        arr[6] = value;
+        break;
+      default:
+        break;
+    }
+  }
+};
+var getDateArray = function getDateArray(str, dateFormat) {
+  var arr = [0, -1, 0, 0, 0, 0];
+  if (str.length !== dateFormat.length) {
+    return arr;
+  }
+  var valuePos = 0;
+  var textPos = 0;
+  for (var i = 0, len = str.length; i < len; i++) {
+    var charValue = str.substr(i, 1);
+    var notNum = isNaN(charValue * 1) || charValue.trim() === '';
+    if (notNum && charValue === dateFormat.substr(i, 1) || i === len - 1) {
+      var value = void 0;
+      var text = void 0;
+      if (notNum) {
+        value = str.substring(valuePos, i);
+        valuePos = i + 1;
+        var end = dateFormat.indexOf(charValue, textPos);
+        text = dateFormat.substring(textPos, end === -1 ? dateFormat.length : end);
+        textPos = end + 1;
+      } else {
+        value = str.substring(valuePos, len);
+        text = dateFormat.substring(textPos, len);
+      }
+      if (value.length === text.length || value) {
+        matchDateArray(arr, value, text);
+      }
+    }
+  }
+  return arr;
+};
+var invalideTime = function invalideTime(time, min, max) {
+  return isNaN(time) || time < min || time > max;
+};
+var invalideValue = function invalideValue(_ref2) {
+  var year = _ref2.year,
+    month = _ref2.month,
+    date = _ref2.date,
+    hours = _ref2.hours,
+    minutes = _ref2.minutes,
+    seconds = _ref2.seconds,
+    milliseconds = _ref2.milliseconds;
+  return invalideTime(year, 0, maxDateValues.YEAR) || invalideTime(month, 0, maxDateValues.MONTH) || invalideTime(date, 0, maxDateValues.DATE) || invalideTime(hours, 0, maxDateValues.HOUR) || invalideTime(minutes, 0, maxDateValues.MINUTE) || invalideTime(seconds, 0, maxDateValues.SECOND) || invalideTime(milliseconds, 0, maxDateValues.MILLISECOND);
+};
+var innerParse = function innerParse(value, dateFormat) {
+  if (typeof dateFormat === 'string') {
+    var arr = getDateArray(value, dateFormat);
+    var year = arr[0] * 1;
+    var month = arr[1] * 1;
+    var date = (arr[2] || 1) * 1;
+    var hours = (arr[3] || 0) * 1;
+    var minutes = (arr[4] || 0) * 1;
+    var seconds = (arr[5] || 0) * 1;
+    var milliseconds = (arr[6] || 0) * 1;
+    if (invalideValue({
+      year: year,
+      month: month,
+      date: date,
+      hours: hours,
+      minutes: minutes,
+      seconds: seconds,
+      milliseconds: milliseconds
+    })) {
+      return;
+    }
+    return getDateFromData({
+      year: year,
+      date: date,
+      month: month,
+      minutes: minutes,
+      hours: hours,
+      milliseconds: milliseconds,
+      seconds: seconds
+    });
+  } else {
+    return parseDate(value);
+  }
+};
+export var toDate = function toDate(value, dateFormat, minDate) {
+  var date;
+  if (isNumber(value)) {
+    date = new Date(value);
+  } else if (typeof value === 'string') {
+    date = innerParse(value, dateFormat);
+  }
+  if (minDate) {
+    var min = minDate && toDate(minDate) || new Date(1, 1, 1, 0, 0, 0);
+    return date && date < min ? min : date;
+  }
+  return date;
+};
+export var format = function format(date) {
+  var dateFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'yyyy/MM/dd hh:mm:ss';
+  if (isDate(date)) {
+    if (typeof dateFormat === 'string') {
+      var o = {
+        'y{1,4}': date.getFullYear(),
+        'M{1,2}': date.getMonth() + 1,
+        'd{1,2}': date.getDate(),
+        'h{1,2}': date.getHours(),
+        'm{1,2}': date.getMinutes(),
+        's{1,2}': date.getSeconds(),
+        'S{1,3}': date.getMilliseconds(),
+        'Z{1,1}': getTimezone(date)
+      };
+      Object.keys(o).forEach(function (k) {
+        var m = dateFormat.match(dateFormatRegs[k]);
+        if (k && m && m.length) {
+          dateFormat = dateFormat.replace(m[0], k === 'Z{1,1}' ? o[k] : fillChar(o[k].toString(), m[0].length));
+        }
+      });
+      return dateFormat;
+    }
+  } else if (typeof date === 'string' && arguments.length >= 2) {
+    var afterFormat = dateFormat;
+    if (arguments.length === 2) {
+      dateFormat = undefined;
+    } else {
+      afterFormat = arguments[2];
+    }
+    var dateValue = toDate(date, dateFormat);
+    return dateValue ? format(dateValue, afterFormat) : '';
+  }
+};
+export var getDateWithNewTimezone = function getDateWithNewTimezone(date, otz, ntz) {
+  if (!isDate(date) || !isNumeric(otz) || !isNumeric(ntz)) {
+    return;
+  }
+  var otzOffset = -otz * 60;
+  var ntzOffset = -ntz * 60;
+  var utc = date.getTime() + otzOffset * 60000;
+  return new Date(utc - ntzOffset * 60000);
+};
+export var toDateStr = function toDateStr(date, dateFormat, timezone) {
+  if (date && isNumeric(timezone)) {
+    timezone = parseFloat(parseFloat(timezone).toFixed(2));
+    date = getDateWithNewTimezone(isDate(date) ? date : new Date(toDate(date)), 0, timezone);
+  }
+  return format(date, dateFormat);
+};
+export var getWeekOfFirstDay = function getWeekOfFirstDay(date, isSunFirst) {
+  typeof date === 'boolean' && (isSunFirst = date);
+  isDate(date) || (date = new Date());
+  var day = date.getDay();
+  var dayOfMonth = date.getDate();
+  if (day === 0) {
+    !isSunFirst && (dayOfMonth -= 6);
+  } else {
+    dayOfMonth = dayOfMonth - day + (!isSunFirst && 1);
+  }
+  return new Date(date.getFullYear(), date.getMonth(), dayOfMonth);
+};
+var TZRE = /(-|\+)(\d{2}):?(\d{2})$/;
+export var getLocalTimezone = function getLocalTimezone() {
+  return 0 - new Date().getTimezoneOffset() / 60;
+};
+export var getStrTimezone = function getStrTimezone(value) {
+  var localTimeZone = getLocalTimezone();
+  var match = typeof value === 'string' && value.match(TZRE);
+  if (match) {
+    var minoffset = match[2] * 1 + match[3] * 1 / 60;
+    value = minoffset * "".concat(match[1], "1");
+  }
+  if (isNumber(value) && value >= -12 && value <= 12) {
+    return value;
+  }
+  return localTimeZone;
+};

package/common/decimal.js

@@ -0,0 +1,203 @@
+import { getMiniDecimal, toFixed as roundFixed } from './bigInt';
+export { roundFixed };
+var DECIMAL_SEPARATOR = '.';
+var asInteger = function asInteger(number) {
+  var tokens = number.split(DECIMAL_SEPARATOR);
+  var integer = tokens[0];
+  var fractional = tokens[1];
+  var value;
+  var exp;
+  if (fractional) {
+    value = parseInt(number.split(DECIMAL_SEPARATOR).join(''), 10);
+    exp = fractional.length * -1;
+  } else {
+    var trailingZeros = integer.match(/0+$/);
+    if (trailingZeros) {
+      var length = trailingZeros[0].length;
+      value = integer.substr(0, integer.length - length);
+      exp = length;
+    } else {
+      value = integer;
+      exp = 0;
+    }
+  }
+  return {
+    value: value,
+    exp: exp
+  };
+};
+var zero = function zero(exp) {
+  var result;
+  if (exp <= 0) {
+    result = '';
+  } else if (String.prototype.repeat) {
+    result = '0'.repeat(exp);
+  } else {
+    result = function (times) {
+      var zeros = [];
+      for (var i = 0; i < times; i++) {
+        zeros.push(0);
+      }
+      return zeros.join('');
+    }(exp);
+  }
+  return result;
+};
+var negExp = function negExp(str, position) {
+  position = Math.abs(position);
+  var offset = position - str.length;
+  var sep = DECIMAL_SEPARATOR;
+  if (offset >= 0) {
+    str = zero(offset) + str;
+    sep = '0.';
+  }
+  var length = str.length;
+  var dif = length - position;
+  var head = str.substr(0, dif);
+  var tail = str.substring(dif, length);
+  return head + sep + tail;
+};
+var posExp = function posExp(str, exp) {
+  return String(str + zero(exp));
+};
+var format = function format(num, exp) {
+  return (exp >= 0 ? posExp : negExp)(String(num), exp);
+};
+export function Decimal(num) {
+  var _this = this;
+  if (!this || this.constructor !== Decimal) {
+    return new Decimal(num);
+  }
+  if (num instanceof Decimal) {
+    return num;
+  }
+  this.internal = String(num);
+  this.asInt = asInteger(this.internal);
+  this.add = function (target) {
+    var operands = [_this, new Decimal(target)];
+    operands.sort(function (x, y) {
+      return x.asInt.exp - y.asInt.exp;
+    });
+    var smallest = operands[0].asInt.exp;
+    var biggest = operands[1].asInt.exp;
+    var x = Number(format(operands[1].asInt.value, biggest - smallest));
+    var y = Number(operands[0].asInt.value);
+    return new Decimal(format(String(x + y), smallest));
+  };
+  this.sub = function (target) {
+    return new Decimal(_this.add(target * -1));
+  };
+  this.mul = function (target) {
+    target = new Decimal(target);
+    var result = String(_this.asInt.value * target.asInt.value);
+    var exp = _this.asInt.exp + target.asInt.exp;
+    return new Decimal(format(result, exp));
+  };
+  this.div = function (target) {
+    target = new Decimal(target);
+    var smallest = Math.min(_this.asInt.exp, target.asInt.exp);
+    var absSmallest = Math.pow(10, Math.abs(smallest));
+    var x = Decimal.mul(absSmallest, _this);
+    var y = Decimal.mul(absSmallest, target);
+    return new Decimal(x / y);
+  };
+  this.toString = function () {
+    return _this.internal;
+  };
+  this.toNumber = function () {
+    return Number(_this.internal);
+  };
+}
+Decimal.add = function (a, b) {
+  return new Decimal(a).add(b);
+};
+Decimal.mul = function (a, b) {
+  return new Decimal(a).mul(b);
+};
+Decimal.sub = function (a, b) {
+  return new Decimal(a).sub(b);
+};
+Decimal.div = function (a, b) {
+  return new Decimal(a).div(b);
+};
+export var toFixed = function toFixed(num) {
+  var fraction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var sign = num < 0 ? '-' : '';
+  num = Math.abs(num);
+  var npmPow = num.toString().length < Math.pow(2, 53).toString().length - 1 ? Math.pow(10, fraction) : Math.pow(10, fraction - 1);
+  var result = new Decimal(Math.round(new Decimal(num).mul(npmPow))).div(npmPow).toString();
+  var numResult = Number(result);
+  return numResult ? sign + numResult.toFixed(fraction) : numResult.toFixed(fraction);
+};
+var formatInteger = function formatInteger(value, _ref) {
+  var _ref$secondaryGroupSi = _ref.secondaryGroupSize,
+    secondaryGroupSize = _ref$secondaryGroupSi === void 0 ? 3 : _ref$secondaryGroupSi,
+    _ref$groupSize = _ref.groupSize,
+    groupSize = _ref$groupSize === void 0 ? 0 : _ref$groupSize,
+    _ref$groupSeparator = _ref.groupSeparator,
+    groupSeparator = _ref$groupSeparator === void 0 ? ',' : _ref$groupSeparator;
+  var negative = /^-\d+/.test(value);
+  var result = negative ? value.slice(1) : value;
+  var secSize = secondaryGroupSize || groupSize;
+  if (groupSize && result.length > groupSize) {
+    var left = result.slice(0, 0 - groupSize);
+    var right = result.slice(0 - groupSize);
+    left = left.replace(new RegExp("\\B(?=(\\d{".concat(secSize, "})+(?!\\d))"), 'g'), groupSeparator);
+    result = "".concat(left).concat(groupSeparator).concat(right);
+  }
+  return "".concat(negative ? '-' : '').concat(result);
+};
+var reverseString = function reverseString(str) {
+  var arr = [];
+  for (var i = 0; i < str.length; i++) {
+    arr.push(str[i]);
+  }
+  return arr.reverse().join('');
+};
+var formatDecimal = function formatDecimal(num, _ref2) {
+  var _ref2$fractionGroupSi = _ref2.fractionGroupSize,
+    fractionGroupSize = _ref2$fractionGroupSi === void 0 ? 0 : _ref2$fractionGroupSi,
+    _ref2$fractionGroupSe = _ref2.fractionGroupSeparator,
+    fractionGroupSeparator = _ref2$fractionGroupSe === void 0 ? '\xA0' : _ref2$fractionGroupSe;
+  var RE = new RegExp("\\B(?=(\\d{".concat(fractionGroupSize, "})+(?!\\d))"), 'g');
+  return reverseString(reverseString(num).replace(RE, fractionGroupSeparator));
+};
+export var formatNumber = function formatNumber(value) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var fraction = format.fraction,
+    rounding = format.rounding,
+    _format$prefix = format.prefix,
+    prefix = _format$prefix === void 0 ? '' : _format$prefix,
+    _format$decimalSepara = format.decimalSeparator,
+    decimalSeparator = _format$decimalSepara === void 0 ? '.' : _format$decimalSepara,
+    _format$suffix = format.suffix,
+    suffix = _format$suffix === void 0 ? '' : _format$suffix;
+  var reslut = getMiniDecimal(value);
+  if (reslut.isNaN() || !reslut.toString()) {
+    return value;
+  }
+  reslut = roundFixed(reslut.toString(), fraction, rounding);
+  format.zeroize === false && reslut.match(/\./) && (reslut = reslut.replace(/\.?0+$/g, ''));
+  var number = reslut.toString().split('.').slice(0, 2).map(function (str, index) {
+    return index ? formatDecimal(str, format) : formatInteger(str, format);
+  }).join(decimalSeparator);
+  return "".concat(prefix).concat(number).concat(suffix);
+};
+export var recoverNumber = function recoverNumber(number) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _format$prefix2 = format.prefix,
+    prefix = _format$prefix2 === void 0 ? '' : _format$prefix2,
+    _format$suffix2 = format.suffix,
+    suffix = _format$suffix2 === void 0 ? '' : _format$suffix2,
+    _format$decimalSepara2 = format.decimalSeparator,
+    decimalSeparator = _format$decimalSepara2 === void 0 ? '.' : _format$decimalSepara2;
+  var result = number;
+  if (typeof number === 'string') {
+    result = number.replace(new RegExp("^".concat(prefix, "(.+)").concat(suffix, "$")), function ($1, $2) {
+      return $2;
+    }).split(decimalSeparator).map(function (s) {
+      return s.replace(/[^\d]/g, '');
+    }).join('.');
+  }
+  return Number(result);
+};