@kdcloudjs/kdesign 1.0.2

package/es/_utils/hooks.js

@@ -0,0 +1,197 @@
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import _Array$from from "@babel/runtime-corejs3/core-js-stable/array/from";
+import _Symbol from "@babel/runtime-corejs3/core-js-stable/symbol";
+import _getIteratorMethod from "@babel/runtime-corejs3/core-js/get-iterator-method";
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && _getIteratorMethod(o) || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { var _context; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context = Object.prototype.toString.call(o)).call(_context, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { useEffect, useState, useRef } from 'react';
+import ResizeObserver from 'resize-observer-polyfill';
+import devWarning from './devwarning';
+/**
+ * @description 点击指定区域外执行回调
+ *
+ * @export
+ * @param {RefObject<HTMLElement>[]} refs
+ * @param {(e: Event) => void} handler
+ */
+
+export function useOnClickOutside(refs, handler) {
+  useEffect(function () {
+    var listener = function listener(event) {
+      var _iterator = _createForOfIteratorHelper(refs),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var ref = _step.value;
+
+          if (!ref.current || ref.current.contains(event.target)) {
+            return;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      handler(event);
+    };
+
+    document.addEventListener('mousedown', listener);
+    document.addEventListener('touchstart', listener);
+    return function () {
+      document.removeEventListener('mousedown', listener);
+      document.removeEventListener('touchstart', listener);
+    };
+  }, [refs, handler]);
+}
+/**
+ * @description 合并状态
+ *
+ * @export
+ * @template T
+ * @template R
+ * @param {(T | (() => T))} defaultStateValue
+ * @param {({
+ *     defaultValue?: T | (() => T)
+ *     value?: T
+ *     onChange?: (value: T, prevValue: T) => void
+ *     postState?: (value: T) => T
+ *   })} [option]
+ * @returns {[R, (value: T) => void]}
+ */
+
+export function useMergedState(defaultStateValue, // 初始state
+option) {
+  var _ref = option || {},
+      defaultValue = _ref.defaultValue,
+      value = _ref.value,
+      onChange = _ref.onChange,
+      postState = _ref.postState;
+
+  var _useState = useState(function () {
+    if (value !== undefined) {
+      return value;
+    }
+
+    if (defaultValue !== undefined) {
+      return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+    }
+
+    return typeof defaultStateValue === 'function' ? defaultStateValue() : defaultStateValue;
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      innerValue = _useState2[0],
+      setInnerValue = _useState2[1];
+
+  var mergedValue = value !== undefined ? value : innerValue;
+
+  if (postState) {
+    mergedValue = postState(mergedValue);
+  }
+
+  function triggerChange(newValue) {
+    setInnerValue(newValue);
+
+    if (mergedValue !== newValue && onChange) {
+      onChange(newValue, mergedValue);
+    }
+  }
+
+  var firstRenderRef = useRef(true);
+  useEffect(function () {
+    if (firstRenderRef.current) {
+      firstRenderRef.current = false;
+      return;
+    }
+
+    if (value === undefined) {
+      setInnerValue(value);
+    }
+  }, [value]);
+  return [mergedValue, triggerChange];
+}
+/**
+ * @description 获取之前的值
+ *
+ * @export
+ * @param {P} value
+ */
+
+export function usePrevious(value) {
+  var ref = useRef(value);
+  useEffect(function () {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+export function useHideDocumentScrollBar(visible, isBody, mask) {
+  useEffect(function () {
+    var isChange = false;
+    var previousDocumentOverflow = document.documentElement.style.overflow;
+
+    if (visible && isBody && mask) {
+      document.documentElement.style.overflow = 'hidden';
+      isChange = true;
+    }
+
+    return function () {
+      if (isChange) {
+        document.documentElement.style.overflow = previousDocumentOverflow;
+      }
+    };
+  }, [visible, isBody, mask]);
+}
+export function useResizeObserver(element, handler) {
+  useEffect(function () {
+    if (typeof element === 'function') {
+      element = element();
+    }
+
+    if (!element) {
+      devWarning(!element && element !== null, 'useResizeMeasure', 'useResizeMeasure指定的元素不存在');
+      return;
+    }
+
+    var measure = function measure(entries) {
+      if (!entries[0] || !entries[0].contentRect) {
+        return;
+      }
+
+      var contentRect = entries[0].contentRect;
+      var hide = contentRect.width === 0 && contentRect.height === 0; // 隐藏条件：高宽都为0
+      // DOMRectReadOnly 对象不可读, 不可赋值
+
+      var rect = _extends({
+        hide: hide
+      }, contentRect);
+
+      ['width', 'height', 'x', 'y', 'bottom', 'top', 'left', 'right'].forEach(function (prop) {
+        rect[prop] = contentRect[prop];
+      }); // rect.width = contentRect.width
+      // rect.height = contentRect.height
+      // rect.x = contentRect.x
+      // rect.y = contentRect.y
+      // rect.bottom = contentRect.bottom
+      // rect.top = contentRect.top
+      // rect.left = contentRect.left
+      // rect.right = contentRect.right
+
+      handler && handler(rect);
+    };
+
+    var resizeObserver = new ResizeObserver(measure);
+    resizeObserver && resizeObserver.observe(element);
+    return function () {
+      resizeObserver && resizeObserver.disconnect();
+    };
+  }, [element, handler]);
+}

package/es/_utils/index.d.ts

@@ -0,0 +1,8 @@
+import compDefaultProps from '../config-provider/compDefaultProps';
+/**
+ * 结合compDefaultProps、用户自定义默认属性和组件当前属性获取组件实际应用属性
+ * @param {keyof typeof compDefaultProps} compName 组件名
+ * @param {any} userDefaultProps 用户自定义组件默认属性
+ * @param {any} compProps 组件接收到的属性
+ */
+export declare const getCompProps: (compName: keyof typeof compDefaultProps, userDefaultProps?: any, compProps?: any) => any;

package/es/_utils/index.js

@@ -0,0 +1,15 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import compDefaultProps from '../config-provider/compDefaultProps'; // kdesign提供组件默认属性
+
+/**
+ * 结合compDefaultProps、用户自定义默认属性和组件当前属性获取组件实际应用属性
+ * @param {keyof typeof compDefaultProps} compName 组件名
+ * @param {any} userDefaultProps 用户自定义组件默认属性
+ * @param {any} compProps 组件接收到的属性
+ */
+
+export var getCompProps = function getCompProps(compName, userDefaultProps, compProps) {
+  var defaultProps = compDefaultProps[compName];
+  var userProps = userDefaultProps && userDefaultProps[compName] || {};
+  return _extends({}, defaultProps, userProps, compProps || {});
+};

package/es/_utils/numberUtil.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 使用定点表示法来格式化一个数
+ * @param  {String|Number}  number     [必选，数字或者表示数字的字符串,范围为[0,20],超过范围则报错]
+ * @param  {Number}  digits  [必选，小数点后数字的个数]
+ * @param  {Boolean} isRound [可选，格式化时是否四舍五入，默认为false，即进行四舍五入,为false时直接截取，不满足位数的往后补0]
+ * @return {String}          [结果]
+ */
+export declare function toFixed(number: string, digits: number, isRound?: boolean): string;
+/**
+ * 将已有的数字进行前面补零的方法
+ * @param {String|Number} number [需要在前面补零的数字]
+ * @param {Number} lenght [补零后的数字长度]
+ * 如：supplementZero(1, 4) return '0001'
+ */
+export declare function supplementZero(number: string, length?: number): string;
+/**
+ *
+ * 序列化字符串为数字，只取字符串中的数字、小数点、正负号
+ * @param {String} strNumber 字符串
+ */
+export declare function serialization(strNumber: string): string;
+export declare function getMaxNumberByPrecision(integerPrecision: number, decimalPrecision: number): number;
+/**
+ * 判断是否为正则表达式
+ * @param {string|number} number 待判断的值
+ */
+export declare function isExp(number: string | number): boolean;
+/**
+ * 将科学计数法显示的数字格式化为正常浮点数
+ * 1e-6 => 0.000006
+ * @param {Number} number 待格式化的科学计数法
+ * @returns num 格式化后的数值，如果不满足科学计数法的话，则原值返回
+ */
+export declare function exponentToFloat(number: string | number): string;

package/es/_utils/numberUtil.js

@@ -0,0 +1,184 @@
+import _Number$isNaN from "@babel/runtime-corejs3/core-js-stable/number/is-nan";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import _fillInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/fill";
+import Big from 'big.js';
+/**
+ * 使用定点表示法来格式化一个数
+ * @param  {String|Number}  number     [必选，数字或者表示数字的字符串,范围为[0,20],超过范围则报错]
+ * @param  {Number}  digits  [必选，小数点后数字的个数]
+ * @param  {Boolean} isRound [可选，格式化时是否四舍五入，默认为false，即进行四舍五入,为false时直接截取，不满足位数的往后补0]
+ * @return {String}          [结果]
+ */
+
+export 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 (_Number$isNaN(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'
+ */
+
+export function supplementZero(number) {
+  var _context;
+
+  var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  number += '';
+  if (number.length > length) return number;
+  return _sliceInstanceProperty(_context = Array(length).join('0') + number).call(_context, -length);
+}
+/**
+ *
+ * 序列化字符串为数字，只取字符串中的数字、小数点、正负号
+ * @param {String} strNumber 字符串
+ */
+
+export 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 + _sliceInstanceProperty(res).call(res, 1);
+  }
+
+  return sign + res;
+} // 根据整数精度和小数精度获取最大值
+
+export function getMaxNumberByPrecision(integerPrecision, decimalPrecision) {
+  var _context2, _context3;
+
+  var integerString = _fillInstanceProperty(_context2 = Array(integerPrecision)).call(_context2, '9').reduce(function (res, value) {
+    return res += value;
+  }, '');
+
+  return decimalPrecision <= 0 ? Number(integerString) : Number(_fillInstanceProperty(_context3 = Array(decimalPrecision)).call(_context3, '9').reduce(function (res, value) {
+    return res += value;
+  }, integerString + '.'));
+}
+/**
+ * 判断是否为正则表达式
+ * @param {string|number} number 待判断的值
+ */
+
+export 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 格式化后的数值，如果不满足科学计数法的话，则原值返回
+ */
+
+export function exponentToFloat(number) {
+  var tempNumber = Number(number);
+  if (isNaN(tempNumber) || !isFinite(tempNumber) || number === '') return tempNumber.toString();
+  var bigNum = new Big(number);
+  var bigNumValue = bigNum.valueOf();
+  var exponentReg = /^(?!-0(\.0+)?(e|$))-?(0|[1-9]\d*)(\.\d+)?(e-?(0|[1-9]\d*))?$/i;
+
+  if (exponentReg.test(bigNumValue)) {
+    // 获取精度， 默认 10
+    var lenArr = exponentReg.exec(bigNumValue);
+    var len = Number(lenArr && lenArr[6] ? lenArr[6] : 10);
+    var fixedNumber = bigNum.toFixed(len).valueOf();
+    var zeros = /^(\d{1,}(?:,\d{3})*\.(?:0*[1-9]+)?)(0*)?$/.exec(fixedNumber);
+
+    if (zeros) {
+      var res = zeros[1];
+      return res[res.length - 1] === '.' ? res.substr(0, res.length - 1) : res;
+    } else {
+      return fixedNumber;
+    }
+  }
+
+  return bigNumValue;
+}

package/es/_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/es/_utils/omit.js

@@ -0,0 +1,11 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+export function omit(obj, fields) {
+  var shallowCopy = _extends({}, obj);
+
+  for (var i = 0; i < fields.length; i++) {
+    var key = fields[i];
+    delete shallowCopy[key];
+  }
+
+  return shallowCopy;
+}

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

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

package/es/_utils/react-children.js

@@ -0,0 +1,8 @@
+import React from 'react';
+export function toArray(children) {
+  var childrens = [];
+  React.Children.forEach(children, function each(c) {
+    childrens.push(c);
+  });
+  return childrens;
+}

package/es/_utils/reactNode.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+declare type AnyObject = Record<any, any>;
+declare type RenderProps = undefined | AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/es/_utils/reactNode.js

@@ -0,0 +1,10 @@
+import * as React from 'react';
+var isValidElement = React.isValidElement;
+export { isValidElement };
+export function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) return replacement;
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+}
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

package/es/_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/es/_utils/type.js

@@ -0,0 +1,15 @@
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+export var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return args;
+};
+export var tupleNum = function tupleNum() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  return args;
+};

package/es/_utils/usePopper.d.ts

@@ -0,0 +1,28 @@
+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;
+    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;