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

package/common/bigInt.js

@@ -1,43 +1,42 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { fillChar } from '@opentiny/vue-renderless/common/string';
-var BigInt = window.BigInt;
-export function supportBigInt() {
-  return typeof BigInt === 'function';
+import "../chunk-PKUHTIDK.js";
+import { fillChar } from "@opentiny/vue-renderless/common/string";
+const BigInt = window.BigInt;
+function supportBigInt() {
+  return typeof BigInt === "function";
 }
-export function trimNumber(numStr) {
-  var string = numStr.toString().trim();
-  var negative = string.startsWith('-');
+function trimNumber(numStr) {
+  let string = numStr.toString().trim();
+  let negative = string.startsWith("-");
   if (negative) {
     string = string.slice(1);
   }
-  string = string.replace(/(\.\d*[^0])0*$/, '$1').replace(/\.0*$/, '').replace(/^0+/, '');
-  if (string.startsWith('.')) {
-    string = '0'.concat(string);
+  string = string.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "");
+  if (string.startsWith(".")) {
+    string = "0".concat(string);
   }
-  var trimStr = string || '0';
-  var splitNumber = trimStr.split('.');
-  var integerStr = splitNumber[0] || '0';
-  var decimalStr = splitNumber[1] || '0';
-  if (integerStr === '0' && decimalStr === '0') {
+  let trimStr = string || "0";
+  let splitNumber = trimStr.split(".");
+  let integerStr = splitNumber[0] || "0";
+  let decimalStr = splitNumber[1] || "0";
+  if (integerStr === "0" && decimalStr === "0") {
     negative = false;
   }
-  var negativeStr = negative ? '-' : '';
+  let negativeStr = negative ? "-" : "";
   return {
-    negative: negative,
-    negativeStr: negativeStr,
-    trimStr: trimStr,
-    integerStr: integerStr,
-    decimalStr: decimalStr,
-    fullStr: ''.concat(negativeStr).concat(trimStr)
+    negative,
+    negativeStr,
+    trimStr,
+    integerStr,
+    decimalStr,
+    fullStr: "".concat(negativeStr).concat(trimStr)
   };
 }
-export function isE(number) {
-  var str = String(number);
-  return !isNaN(Number(str)) && ~str.indexOf('e');
+function isE(number) {
+  let str = String(number);
+  return !isNaN(Number(str)) && ~str.indexOf("e");
 }
-export function validateNumber(num) {
-  if (typeof num === 'number') {
+function validateNumber(num) {
+  if (typeof num === "number") {
     return !isNaN(num);
   }
   if (!num) {
@@ -45,20 +44,20 @@ export function validateNumber(num) {
   }
   return /^\s*-?\d+(\.\d+)?\s*$/.test(num) || /^\s*-?\d+\.\s*$/.test(num) || /^\s*-?\.\d+\s*$/.test(num);
 }
-export function getNumberPrecision(number) {
-  var numStr = String(number);
+function getNumberPrecision(number) {
+  let numStr = String(number);
   if (isE(number)) {
-    var precision = Number(numStr.slice(numStr.indexOf('e-') + 2));
-    var decimalMatch = numStr.match(/\.(\d+)/);
+    let precision = Number(numStr.slice(numStr.indexOf("e-") + 2));
+    let decimalMatch = numStr.match(/\.(\d+)/);
     if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
       precision += decimalMatch[1].length;
     }
     return precision;
   }
-  return ~numStr.indexOf('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;
+  return ~numStr.indexOf(".") && validateNumber(numStr) ? numStr.length - numStr.indexOf(".") - 1 : 0;
 }
-export function num2str(number) {
-  var numStr = String(number);
+function num2str(number) {
+  let numStr = String(number);
   if (isE(number)) {
     if (number > Number.MAX_SAFE_INTEGER) {
       return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
@@ -80,19 +79,18 @@ function pluginDecimal(decimal) {
   }
   return decimal;
 }
-var DecimalCls = {
+const DecimalCls = {
   CLS: null
 };
-var setDecimalClass;
-export function getMiniDecimal(value, decimal) {
+let setDecimalClass;
+function getMiniDecimal(value, decimal) {
   if (!DecimalCls.CLS) {
     setDecimalClass(decimal);
   }
   return pluginDecimal(new DecimalCls.CLS(value));
 }
-export var BigIntDecimal = function () {
-  function BigIntDecimal(value) {
-    _classCallCheck(this, BigIntDecimal);
+class BigIntDecimal {
+  constructor(value) {
     if (!value && value !== 0 || !String(value).trim()) {
       this.empty = true;
       return;
@@ -104,252 +102,198 @@ export var BigIntDecimal = function () {
     this.decimalLen = void 0;
     this.empty = void 0;
     this.nan = void 0;
-    if (value === '-') {
+    if (value === "-") {
       this.nan = true;
       return;
     }
-    var mergedValue = isE(value) ? Number(value) : value;
-    if (typeof mergedValue !== 'string') {
+    let mergedValue = isE(value) ? Number(value) : value;
+    if (typeof mergedValue !== "string") {
       num2str(mergedValue);
     }
-    var f = Function;
-    var convertBigInt = function convertBigInt(str) {
-      return f("return BigInt(".concat(str, ")"))();
-    };
+    const f = Function;
+    const convertBigInt = (str) => f(`return BigInt(${str})`)();
     if (validateNumber(mergedValue)) {
-      var trimRet = trimNumber(mergedValue);
+      const trimRet = trimNumber(mergedValue);
       this.negative = trimRet.negative;
-      var numbers = trimRet.trimStr.split('.');
+      const numbers = trimRet.trimStr.split(".");
       this.integer = BigInt(numbers[0]);
-      var decimalStr = numbers[1] || '0';
+      const decimalStr = numbers[1] || "0";
       this.decimal = convertBigInt(decimalStr);
     } else {
       this.nan = true;
     }
   }
-  _createClass(BigIntDecimal, [{
-    key: "getDecimalStr",
-    value: function getDecimalStr() {
-      return this.decimal.toString().padStart(this.decimalLen, '0');
-    }
-  }, {
-    key: "getIntegerStr",
-    value: function getIntegerStr() {
-      return this.integer.toString();
-    }
-  }, {
-    key: "getMark",
-    value: function getMark() {
-      return this.negative ? '-' : '';
-    }
-  }, {
-    key: "alignDecimal",
-    value: function alignDecimal(decimalLength) {
-      var string = "".concat(this.getMark()).concat(this.getIntegerStr()).concat(this.getDecimalStr().padEnd(decimalLength, '0'));
-      return BigInt(string);
-    }
-  }, {
-    key: "add",
-    value: function add(value) {
-      if (this.isInvalidate()) {
-        return new BigIntDecimal(value);
-      }
-      var offsetObj = new BigIntDecimal(value);
-      if (offsetObj.isInvalidate()) {
-        return this;
-      }
-      var maxDecimalLength = Math.max(this.getDecimalStr().length, offsetObj.getDecimalStr().length);
-      var offsetAlignedDecimal = offsetObj.alignDecimal(maxDecimalLength);
-      var myAlignedDecimal = this.alignDecimal(maxDecimalLength);
-      var valueStr = "".concat(myAlignedDecimal + offsetAlignedDecimal);
-      var _trimNumber = trimNumber(valueStr),
-        str = _trimNumber.negativeStr,
-        trimStr = _trimNumber.trimStr;
-      var hydrateValueStr = "".concat(str).concat(trimStr.padStart(maxDecimalLength + 1, '0'));
-      return getMiniDecimal("".concat(hydrateValueStr.slice(0, -maxDecimalLength), ".").concat(hydrateValueStr.slice(-maxDecimalLength)));
-    }
-  }, {
-    key: "negate",
-    value: function negate() {
-      var clone = new BigIntDecimal(this.toString());
-      clone.negative = !clone.negative;
-      return clone;
-    }
-  }, {
-    key: "isNaN",
-    value: function isNaN() {
-      return this.nan;
-    }
-  }, {
-    key: "isEmpty",
-    value: function isEmpty() {
-      return this.empty;
-    }
-  }, {
-    key: "isInvalidate",
-    value: function isInvalidate() {
-      return this.isEmpty() || this.isNaN();
+  getDecimalStr() {
+    return this.decimal.toString().padStart(this.decimalLen, "0");
+  }
+  getIntegerStr() {
+    return this.integer.toString();
+  }
+  getMark() {
+    return this.negative ? "-" : "";
+  }
+  alignDecimal(decimalLength) {
+    const string = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(decimalLength, "0")}`;
+    return BigInt(string);
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new BigIntDecimal(value);
     }
-  }, {
-    key: "lessEquals",
-    value: function lessEquals(target) {
-      return this.add(target.negate().toString()).toNumber() <= 0;
+    const offsetObj = new BigIntDecimal(value);
+    if (offsetObj.isInvalidate()) {
+      return this;
     }
-  }, {
-    key: "equals",
-    value: function equals(target) {
-      return this.toString() === (target && target.toString());
+    const maxDecimalLength = Math.max(this.getDecimalStr().length, offsetObj.getDecimalStr().length);
+    const offsetAlignedDecimal = offsetObj.alignDecimal(maxDecimalLength);
+    const myAlignedDecimal = this.alignDecimal(maxDecimalLength);
+    const valueStr = `${myAlignedDecimal + offsetAlignedDecimal}`;
+    const { negativeStr: str, trimStr } = trimNumber(valueStr);
+    const hydrateValueStr = `${str}${trimStr.padStart(maxDecimalLength + 1, "0")}`;
+    return getMiniDecimal(`${hydrateValueStr.slice(0, -maxDecimalLength)}.${hydrateValueStr.slice(-maxDecimalLength)}`);
+  }
+  negate() {
+    const clone = new BigIntDecimal(this.toString());
+    clone.negative = !clone.negative;
+    return clone;
+  }
+  isNaN() {
+    return this.nan;
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  equals(target) {
+    return this.toString() === (target && target.toString());
+  }
+  toNumber() {
+    if (this.isNaN()) {
+      return NaN;
     }
-  }, {
-    key: "toNumber",
-    value: function toNumber() {
-      if (this.isNaN()) {
-        return NaN;
-      }
-      return Number(this.toString());
+    return Number(this.toString());
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
     }
-  }, {
-    key: "toString",
-    value: function toString() {
-      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      if (!safe) {
-        return this.origin;
-      }
-      if (this.isInvalidate()) {
-        return '';
-      }
-      return trimNumber("".concat(this.getMark()).concat(this.getIntegerStr(), ".").concat(this.getDecimalStr())).fullStr;
+    if (this.isInvalidate()) {
+      return "";
     }
-  }]);
-  return BigIntDecimal;
-}();
-export var NumberDecimal = function () {
-  function NumberDecimal() {
-    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    _classCallCheck(this, NumberDecimal);
+    return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr;
+  }
+}
+class NumberDecimal {
+  constructor(value = "") {
     if (!value && value !== 0 || !String(value).trim()) {
       this.empty = true;
       return;
     }
-    this.origin = '';
+    this.origin = "";
     this.number = void 0;
     this.empty = void 0;
     this.origin = String(value);
     this.number = Number(value);
   }
-  _createClass(NumberDecimal, [{
-    key: "negate",
-    value: function negate() {
-      return new NumberDecimal(-this.toNumber());
-    }
-  }, {
-    key: "add",
-    value: function add(value) {
-      if (this.isInvalidate()) {
-        return new NumberDecimal(value);
-      }
-      var target = Number(value);
-      if (isNaN(target)) {
-        return this;
-      }
-      var number = this.number + target;
-      if (number < Number.MIN_SAFE_INTEGER) {
-        return new NumberDecimal(Number.MIN_SAFE_INTEGER);
-      }
-      if (number > Number.MAX_SAFE_INTEGER) {
-        return new NumberDecimal(Number.MAX_SAFE_INTEGER);
-      }
-      var maxPrecision = Math.max(getNumberPrecision(target), getNumberPrecision(this.number));
-      return new NumberDecimal(number.toFixed(maxPrecision));
-    }
-  }, {
-    key: "isNaN",
-    value: function (_isNaN) {
-      function isNaN() {
-        return _isNaN.apply(this, arguments);
-      }
-      isNaN.toString = function () {
-        return _isNaN.toString();
-      };
-      return isNaN;
-    }(function () {
-      return isNaN(this.number);
-    })
-  }, {
-    key: "isEmpty",
-    value: function isEmpty() {
-      return this.empty;
+  negate() {
+    return new NumberDecimal(-this.toNumber());
+  }
+  add(value) {
+    if (this.isInvalidate()) {
+      return new NumberDecimal(value);
     }
-  }, {
-    key: "isInvalidate",
-    value: function isInvalidate() {
-      return this.isEmpty() || this.isNaN();
+    const target = Number(value);
+    if (isNaN(target)) {
+      return this;
     }
-  }, {
-    key: "equals",
-    value: function equals(target) {
-      return this.toNumber() === (target && target.toNumber());
+    const number = this.number + target;
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MIN_SAFE_INTEGER);
     }
-  }, {
-    key: "lessEquals",
-    value: function lessEquals(target) {
-      return this.add(target.negate().toString()).toNumber() <= 0;
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return new NumberDecimal(Number.MAX_SAFE_INTEGER);
     }
-  }, {
-    key: "toNumber",
-    value: function toNumber() {
-      return this.number;
+    const maxPrecision = Math.max(getNumberPrecision(target), getNumberPrecision(this.number));
+    return new NumberDecimal(number.toFixed(maxPrecision));
+  }
+  isNaN() {
+    return isNaN(this.number);
+  }
+  isEmpty() {
+    return this.empty;
+  }
+  isInvalidate() {
+    return this.isEmpty() || this.isNaN();
+  }
+  equals(target) {
+    return this.toNumber() === (target && target.toNumber());
+  }
+  lessEquals(target) {
+    return this.add(target.negate().toString()).toNumber() <= 0;
+  }
+  toNumber() {
+    return this.number;
+  }
+  toString(safe = true) {
+    if (!safe) {
+      return this.origin;
     }
-  }, {
-    key: "toString",
-    value: function toString() {
-      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      if (!safe) {
-        return this.origin;
-      }
-      if (this.isInvalidate()) {
-        return '';
-      }
-      return num2str(this.number);
+    if (this.isInvalidate()) {
+      return "";
     }
-  }]);
-  return NumberDecimal;
-}();
-setDecimalClass = function setDecimalClass(decimaljs) {
-  DecimalCls.CLS = supportBigInt() ? BigIntDecimal : typeof decimaljs === 'function' ? decimaljs : NumberDecimal;
+    return num2str(this.number);
+  }
+}
+setDecimalClass = function(decimaljs) {
+  DecimalCls.CLS = supportBigInt() ? BigIntDecimal : typeof decimaljs === "function" ? decimaljs : NumberDecimal;
 };
-export { setDecimalClass };
-export function lessEquals(value1, value2) {
+function lessEquals(value1, value2) {
   return getMiniDecimal(value1).lessEquals(getMiniDecimal(value2));
 }
-export function equalsDecimal(value1, value2) {
+function equalsDecimal(value1, value2) {
   return getMiniDecimal(value1).equals(getMiniDecimal(value2));
 }
-export function toFixed(numStr, precision) {
-  var rounding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
-  if (numStr === '') {
-    return '';
-  }
-  var separatorStr = '.';
-  var _trimNumber2 = trimNumber(numStr),
-    negativeStr = _trimNumber2.negativeStr,
-    integerStr = _trimNumber2.integerStr,
-    decimalStr = _trimNumber2.decimalStr;
-  var precisionDecimalStr = "".concat(separatorStr).concat(decimalStr);
-  var numberWithoutDecimal = "".concat(negativeStr).concat(integerStr);
+function toFixed(numStr, precision, rounding = 5) {
+  if (numStr === "") {
+    return "";
+  }
+  const separatorStr = ".";
+  const { negativeStr, integerStr, decimalStr } = trimNumber(numStr);
+  const precisionDecimalStr = `${separatorStr}${decimalStr}`;
+  const numberWithoutDecimal = `${negativeStr}${integerStr}`;
   if (precision >= 0) {
-    var advancedNum = Number(decimalStr[precision]);
+    const advancedNum = Number(decimalStr[precision]);
     if (advancedNum >= rounding && rounding !== 0) {
-      var advancedDecimal = getMiniDecimal("".concat(integerStr).concat(separatorStr).concat(decimalStr)).add("0.".concat(fillChar('', precision, true)).concat(10 - advancedNum));
+      const advancedDecimal = getMiniDecimal(`${integerStr}${separatorStr}${decimalStr}`).add(`0.${fillChar("", precision, true)}${10 - advancedNum}`);
       return toFixed(negativeStr + advancedDecimal.toString(), precision, 0);
     }
     if (precision === 0) {
       return numberWithoutDecimal;
     }
-    return "".concat(numberWithoutDecimal).concat(separatorStr).concat(fillChar(decimalStr, precision, true).slice(0, precision));
+    return `${numberWithoutDecimal}${separatorStr}${fillChar(decimalStr, precision, true).slice(0, precision)}`;
   }
-  if (precisionDecimalStr === '.0') {
+  if (precisionDecimalStr === ".0") {
     return numberWithoutDecimal;
   }
-  return "".concat(numberWithoutDecimal).concat(precisionDecimalStr);
-}
+  return `${numberWithoutDecimal}${precisionDecimalStr}`;
+}
+export {
+  BigIntDecimal,
+  NumberDecimal,
+  equalsDecimal,
+  getMiniDecimal,
+  getNumberPrecision,
+  isE,
+  lessEquals,
+  num2str,
+  setDecimalClass,
+  supportBigInt,
+  toFixed,
+  trimNumber,
+  validateNumber
+};

package/common/browser.js

@@ -1,5 +1,6 @@
-var getIEVersion = function getIEVersion() {
-  var version = 8;
+import "../chunk-PKUHTIDK.js";
+const getIEVersion = () => {
+  let version = 8;
   if (!!document.addEventListener && !!window.performance) {
     version = 9;
     if (!!window.atob && !!window.matchMedia) {
@@ -11,59 +12,62 @@ var getIEVersion = function getIEVersion() {
   }
   return version;
 };
-var isEdge = function isEdge(browser) {
-  if (browser.chrome && ~navigator.userAgent.indexOf('Edg')) {
-    browser.name = 'edge';
+const isEdge = (browser) => {
+  if (browser.chrome && ~navigator.userAgent.indexOf("Edg")) {
+    browser.name = "edge";
     browser.edge = true;
     delete browser.chrome;
   } else if (!document.documentMode && !!window.StyleMedia) {
-    browser.name = 'edge';
+    browser.name = "edge";
     browser.edge = true;
   }
 };
-export default (function () {
-  var isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
-  var browser = {
-    name: undefined,
-    version: undefined,
-    isDoc: typeof document !== 'undefined',
-    isMobile: isMobile,
+var browser_default = (() => {
+  const isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+  const browser = {
+    name: void 0,
+    version: void 0,
+    isDoc: typeof document !== "undefined",
+    isMobile,
     isPC: !isMobile,
-    isNode: typeof window === 'undefined'
+    isNode: typeof window === "undefined"
   };
-  var matches;
+  let matches;
   if (!!window.chrome && (!!window.chrome.webstore || /^Google\b/.test(window.navigator.vendor))) {
-    browser.name = 'chrome';
+    browser.name = "chrome";
     browser.chrome = true;
     matches = navigator.userAgent.match(/chrome\/(\d+)/i);
     browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
-    matches = undefined;
+    matches = void 0;
   } else if (!!document.all || !!document.documentMode) {
-    browser.name = 'ie';
+    browser.name = "ie";
     browser.version = getIEVersion();
     browser.ie = true;
-  } else if (typeof window.InstallTrigger !== 'undefined') {
-    browser.name = 'firefox';
+  } else if (typeof window.InstallTrigger !== "undefined") {
+    browser.name = "firefox";
     browser.firefox = true;
-  } else if (Object.prototype.toString.call(window.HTMLElement).indexOf('Constructor') > 0) {
-    browser.name = 'safari';
+  } else if (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") > 0) {
+    browser.name = "safari";
     browser.safari = true;
   } else if (!!window.opr && !!window.opr.addons || !!window.opera) {
-    browser.name = 'opera';
+    browser.name = "opera";
     browser.opera = true;
   }
   isEdge(browser);
-  if (!~['ie', 'chrome'].indexOf(browser.name)) {
-    var reg = browser.name + '/(\\d+)';
-    matches = navigator.userAgent.match(new RegExp(reg, 'i'));
+  if (!~["ie", "chrome"].indexOf(browser.name)) {
+    const reg = browser.name + "/(\\d+)";
+    matches = navigator.userAgent.match(new RegExp(reg, "i"));
     browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
-    matches = undefined;
+    matches = void 0;
   }
   if (browser.isDoc) {
-    var bodyEl = document.body || document.documentElement;
-    ['webkit', 'khtml', 'moz', 'ms', 'o'].forEach(function (core) {
-      browser['-' + core] = !!bodyEl[core + 'MatchesSelector'];
+    const bodyEl = document.body || document.documentElement;
+    ["webkit", "khtml", "moz", "ms", "o"].forEach((core) => {
+      browser["-" + core] = !!bodyEl[core + "MatchesSelector"];
     });
   }
   return browser;
-})();
+})();
+export {
+  browser_default as default
+};