@kdcloudjs/table 1.0.0

package/lib/_utils/numberUtil.js

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toFixed = toFixed;
+exports.supplementZero = supplementZero;
+exports.serialization = serialization;
+exports.getMaxNumberByPrecision = getMaxNumberByPrecision;
+exports.isExp = isExp;
+exports.exponentToFloat = exponentToFloat;
+
+var _isNan = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/number/is-nan"));
+
+var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
+
+var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
+
+var _fill = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/fill"));
+
+/**
+ * 使用定点表示法来格式化一个数
+ * @param  {String|Number}  number     [必选，数字或者表示数字的字符串,范围为[0,20],超过范围则报错]
+ * @param  {Number}  digits  [必选，小数点后数字的个数]
+ * @param  {Boolean} isRound [可选，格式化时是否四舍五入，默认为false，即进行四舍五入,为false时直接截取，不满足位数的往后补0]
+ * @return {String}          [结果]
+ */
+function toFixed(number, digits) {
+  var isRound = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+  // 非数字
+  // if (!/(^-\d+|^\d+)\.?\d*$/gi.test(number)) { // Number.isFinite(number)
+  //   throw new Error('toFixed() number argument must be a valid number')
+  // }
+  if ((0, _isNan.default)(Number(number))) {
+    throw new Error('toFixed() number argument must be a valid number');
+  } // 是否为正数
+
+
+  var isPositive = +number >= 0; // 转化为字符串
+
+  number += '';
+  isRound = Boolean(isRound); // 去掉正负号，统一按照正数来处理，最后再加上符号
+
+  number = number.replace(/^(?:-|\+)/gi, ''); // 小数点过大
+
+  if (digits > 20 || digits < 0) {
+    throw new RangeError('toFixed() digits argument must be between 0 and 20');
+  } // 如果是简写如.11则整数位补0，变成0.11
+
+
+  if (/^\./gi.test(number)) {
+    number = '0' + number;
+  }
+
+  var numParts = number.split('.');
+  var result = ''; // 在str后面加n个0
+
+  var _paddingZero = function _paddingZero(str, n) {
+    for (var i = 0; i < n; i++) {
+      str += '0';
+    }
+
+    return str;
+  }; // 在str后面加0，直至str的长度达到n
+  // 如果超过了n，则直接截取前n个字符串
+
+
+  var _paddingZeroTo = function _paddingZeroTo(str, n) {
+    if (str.length >= n) {
+      return str.substr(0, n);
+    } else {
+      return _paddingZero(str, n - str.length);
+    }
+  }; // 直接就是整数
+
+
+  if (numParts.length < 2) {
+    result = numParts[0] + '.' + _paddingZero('', digits);
+  } else {
+    // 为浮点数
+    // 如果为截取
+    if (isRound === false) {
+      result = numParts[0] + '.' + _paddingZeroTo(numParts[1], digits); // 如果为四舍五入
+    } else {
+      // 放大10的N次方倍
+      var enlarge = numParts[0] + _paddingZeroTo(numParts[1], digits) + '.' + numParts[1].substr(digits); // 取整
+
+      enlarge = Math.round(parseFloat(enlarge)) + ''; // 缩小10的N次方
+
+      while (enlarge.length <= digits) {
+        enlarge = '0' + enlarge;
+      }
+
+      result = enlarge.substr(0, enlarge.length - digits) + '.' + enlarge.substr(enlarge.length - digits);
+    }
+  } // 如果最后一位为.,则去除
+
+
+  result = result.replace(/\.$/gi, '').replace(/^\./gi, '0.'); // 加上正负数符号位
+
+  result = isPositive ? result : '-' + result;
+  return result;
+}
+/**
+ * 将已有的数字进行前面补零的方法
+ * @param {String|Number} number [需要在前面补零的数字]
+ * @param {Number} lenght [补零后的数字长度]
+ * 如：supplementZero(1, 4) return '0001'
+ */
+
+
+function supplementZero(number) {
+  var _context;
+
+  var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  number += '';
+  if (number.length > length) return number;
+  return (0, _slice.default)(_context = Array(length).join('0') + number).call(_context, -length);
+}
+/**
+ *
+ * 序列化字符串为数字，只取字符串中的数字、小数点、正负号
+ * @param {String} strNumber 字符串
+ */
+
+
+function serialization(strNumber) {
+  var numberList = strNumber.match(/\d|^-|\./g);
+  if (!numberList) return ''; // 取出正负号
+
+  var sign = numberList[0] === '-' ? '-' : '';
+
+  if (sign === '-') {
+    // 有负号, 去掉数组的负号
+    numberList.shift();
+  }
+
+  var numberString = numberList.join(''); // .replace('.', 'a').replace(/\./g, '').replace('a', '.')
+
+  var res = numberString.replace(/^0{2,}/gi, '0');
+
+  if (/^(0[^.])/gi.test(res)) {
+    return sign + (0, _slice.default)(res).call(res, 1);
+  }
+
+  return sign + res;
+} // 根据整数精度和小数精度获取最大值
+
+
+function getMaxNumberByPrecision(integerPrecision, decimalPrecision) {
+  var _context2, _context3, _context4, _context5;
+
+  var integerString = (0, _reduce.default)(_context2 = (0, _fill.default)(_context3 = Array(integerPrecision)).call(_context3, '9')).call(_context2, function (res, value) {
+    return res += value;
+  }, '');
+  return decimalPrecision <= 0 ? Number(integerString) : Number((0, _reduce.default)(_context4 = (0, _fill.default)(_context5 = Array(decimalPrecision)).call(_context5, '9')).call(_context4, function (res, value) {
+    return res += value;
+  }, integerString + '.'));
+}
+/**
+ * 判断是否为正则表达式
+ * @param {string|number} number 待判断的值
+ */
+
+
+function isExp(number) {
+  number = Number(number);
+  if (isNaN(number) || !isFinite(number)) return false;
+  return /^(?!-0(\.0+)?(e|$))-?(0|[1-9]\d*)(\.\d+)?(e-?(0|[1-9]\d*))?$/i.test(number.toString());
+}
+/**
+ * 将科学计数法显示的数字格式化为正常浮点数
+ * 1e-6 => 0.000006
+ * @param {Number} number 待格式化的科学计数法
+ * @returns num 格式化后的数值，如果不满足科学计数法的话，则原值返回
+ */
+
+
+function exponentToFloat(number) {
+  var tempNumber = Number(number);
+  if (isNaN(tempNumber) || !isFinite(tempNumber)) return number.toString();
+  var exponentReg = /^(?!-0(\.0+)?(e|$))-?(0|[1-9]\d*)(\.\d+)?(e-?(0|[1-9]\d*))?$/i;
+
+  if (exponentReg.test(tempNumber.toString())) {
+    // 获取精度， 默认 10
+    var lenArr = exponentReg.exec(tempNumber.toString());
+    var len = Number(lenArr && lenArr[6] ? lenArr[6] : 10);
+    var zeros = /^(\d{1,}(?:,\d{3})*\.(?:0*[1-9]+)?)(0*)?$/.exec(tempNumber.toFixed(len));
+
+    if (zeros) {
+      var res = zeros[1];
+      return res[res.length - 1] === '.' ? res.substr(0, res.length - 1) : res;
+    } else {
+      return tempNumber.toFixed(len);
+    }
+  }
+
+  return tempNumber.toString();
+}

package/lib/_utils/omit.d.ts

@@ -0,0 +1 @@
+export declare function omit<T, K extends keyof T>(obj: T, fields: Array<K>): Pick<T, Exclude<keyof T, K>>;

package/lib/_utils/omit.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.omit = omit;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+function omit(obj, fields) {
+  var shallowCopy = (0, _extends2.default)({}, obj);
+
+  for (var i = 0; i < fields.length; i++) {
+    var key = fields[i];
+    delete shallowCopy[key];
+  }
+
+  return shallowCopy;
+}

package/lib/_utils/react-children.d.ts

@@ -0,0 +1,2 @@
+import { ReactNode } from 'react';
+export declare function toArray(children: ReactNode): ReactNode[];

package/lib/_utils/react-children.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArray = toArray;
+
+var _react = _interopRequireDefault(require("react"));
+
+function toArray(children) {
+  var childrens = [];
+
+  _react.default.Children.forEach(children, function each(c) {
+    childrens.push(c);
+  });
+
+  return childrens;
+}

package/lib/_utils/type.d.ts

@@ -0,0 +1,12 @@
+export declare type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export declare type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer E)[] ? E : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export declare type LiteralUnion<T extends U, U> = T | (U & Record<string, unknown>);

package/lib/_utils/type.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tupleNum = exports.tuple = void 0;
+
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return args;
+};
+
+exports.tuple = tuple;
+
+var tupleNum = function tupleNum() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  return args;
+};
+
+exports.tupleNum = tupleNum;

package/lib/_utils/usePopper.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+export declare const Placements: ["top", "left", "right", "bottom", "topLeft", "topRight", "bottomLeft", "bottomRight", "leftTop", "leftBottom", "rightTop", "rightBottom"];
+export declare type PlacementType = typeof Placements[number];
+export declare const Triggers: ["hover", "focus", "click", "contextMenu"];
+export declare type TriggerType = typeof Triggers[number];
+export interface PopperProps {
+    gap?: number;
+    arrow?: boolean;
+    visible?: boolean;
+    prefixCls?: string;
+    arrowSize?: number;
+    disabled?: boolean;
+    arrowOffset?: number;
+    scrollHidden?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    defaultVisible?: boolean;
+    popperClassName?: string;
+    placement?: PlacementType;
+    locatorClassName?: string;
+    popperStyle?: React.CSSProperties;
+    trigger?: TriggerType | Array<TriggerType>;
+    onTrigger?: (trigger: TriggerType) => void;
+    onVisibleChange?: (visible: boolean) => void;
+    getTriggerElement?: (locatorNode: HTMLElement) => HTMLElement;
+    getPopupContainer?: (locatorNode: HTMLElement) => HTMLElement;
+}
+declare function usePopper(locatorElement: React.ReactElement, popperElement: React.ReactElement, props: PopperProps): JSX.Element;
+export default usePopper;