@aloudata/aloudata-design 1.3.1 → 1.4.1

package/dist/DataPreviewTable/hooks/useDirection.js

@@ -0,0 +1,281 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || 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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(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; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { CELL_HEIGHT, DEFAULT_COLUMN_WIDTH, PRE_RENDER_RANGE } from "../constant";
+import { findFirstIndex } from "../utils/findRange";
+export var EScrollHorizontalDirection;
+
+(function (EScrollHorizontalDirection) {
+  EScrollHorizontalDirection["SCROLL_TO_LEFT"] = "toLeft";
+  EScrollHorizontalDirection["SCROLL_TO_RIGHT"] = "toRight";
+})(EScrollHorizontalDirection || (EScrollHorizontalDirection = {}));
+
+export var EScrollVerticalDirection;
+
+(function (EScrollVerticalDirection) {
+  EScrollVerticalDirection["SCROLL_TO_TOP"] = "toTop";
+  EScrollVerticalDirection["SCROLL_TO_BOTTOM"] = "toBottom";
+})(EScrollVerticalDirection || (EScrollVerticalDirection = {}));
+
+export default function useDirection(columns, wrapRef) {
+  var prevScrollData = useRef({
+    scrollTop: 0,
+    scrollLeft: 0,
+    direction: {
+      vertical: EScrollVerticalDirection.SCROLL_TO_BOTTOM,
+      horizontal: EScrollHorizontalDirection.SCROLL_TO_RIGHT,
+      current: 'init'
+    }
+  });
+
+  var _useState = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      columnsWidth = _useState2[0],
+      setColumnsWidth = _useState2[1];
+
+  var _useState3 = useState([0, 0]),
+      _useState4 = _slicedToArray(_useState3, 2),
+      columnRange = _useState4[0],
+      setColumnRange = _useState4[1];
+
+  var _useState5 = useState([0, 0]),
+      _useState6 = _slicedToArray(_useState5, 2),
+      rowRange = _useState6[0],
+      setRowRange = _useState6[1];
+
+  var getScrollDirection = useCallback(function (currentScrollTop, currentScrollLeft) {
+    var _prevScrollData$curre = prevScrollData.current,
+        preScrollTop = _prevScrollData$curre.scrollTop,
+        preScrollLeft = _prevScrollData$curre.scrollLeft;
+
+    if (currentScrollLeft > preScrollLeft) {
+      var direction = {
+        vertical: EScrollVerticalDirection.SCROLL_TO_BOTTOM,
+        horizontal: EScrollHorizontalDirection.SCROLL_TO_RIGHT,
+        current: EScrollHorizontalDirection.SCROLL_TO_RIGHT
+      };
+      prevScrollData.current = {
+        scrollTop: currentScrollTop,
+        scrollLeft: currentScrollLeft,
+        direction: direction
+      };
+      return direction;
+    } else if (currentScrollLeft < preScrollLeft) {
+      var _direction = {
+        vertical: EScrollVerticalDirection.SCROLL_TO_BOTTOM,
+        horizontal: EScrollHorizontalDirection.SCROLL_TO_LEFT,
+        current: EScrollHorizontalDirection.SCROLL_TO_LEFT
+      };
+      prevScrollData.current = {
+        scrollTop: currentScrollTop,
+        scrollLeft: currentScrollLeft,
+        direction: _direction
+      };
+      return _direction;
+    } else if (currentScrollTop > preScrollTop) {
+      var _direction2 = {
+        vertical: EScrollVerticalDirection.SCROLL_TO_BOTTOM,
+        horizontal: EScrollHorizontalDirection.SCROLL_TO_RIGHT,
+        current: EScrollVerticalDirection.SCROLL_TO_BOTTOM
+      };
+      prevScrollData.current = {
+        scrollTop: currentScrollTop,
+        scrollLeft: currentScrollLeft,
+        direction: _direction2
+      };
+      return _direction2;
+    } else if (currentScrollTop < preScrollTop) {
+      var _direction3 = {
+        vertical: EScrollVerticalDirection.SCROLL_TO_TOP,
+        horizontal: EScrollHorizontalDirection.SCROLL_TO_RIGHT,
+        current: EScrollVerticalDirection.SCROLL_TO_TOP
+      };
+      prevScrollData.current = {
+        scrollTop: currentScrollTop,
+        scrollLeft: currentScrollLeft,
+        direction: _direction3
+      };
+      return _direction3;
+    } else {
+      return prevScrollData.current.direction;
+    }
+  }, []);
+  var columnsOffsets = useMemo(function () {
+    var offset = 0;
+    return columnsWidth.map(function (width) {
+      var currentOffset = offset;
+      offset += width;
+      return currentOffset;
+    });
+  }, [columnsWidth]);
+  var setRange = useCallback(function (scrollTop, scrollLeft) {
+    var direction = getScrollDirection(scrollTop, scrollLeft);
+    var current = direction.current;
+
+    if (current === EScrollHorizontalDirection.SCROLL_TO_LEFT) {
+      var _wrapRef$current;
+
+      // 往左滚动
+      var wrapWidth = ((_wrapRef$current = wrapRef.current) === null || _wrapRef$current === void 0 ? void 0 : _wrapRef$current.clientWidth) || 0;
+      setColumnRange(function (prev) {
+        var _prev = _slicedToArray(prev, 2),
+            start = _prev[0],
+            end = _prev[1];
+
+        var firstIndex = findFirstIndex(columnsOffsets, scrollLeft - PRE_RENDER_RANGE);
+        var lastIndex = findFirstIndex(columnsOffsets, scrollLeft + wrapWidth);
+
+        if (firstIndex === start && lastIndex === end) {
+          return prev;
+        }
+
+        return [firstIndex, lastIndex + 1];
+      });
+    }
+
+    if (current === EScrollHorizontalDirection.SCROLL_TO_RIGHT || current === 'init') {
+      var _wrapRef$current2;
+
+      // 往右滚动
+      var _wrapWidth = ((_wrapRef$current2 = wrapRef.current) === null || _wrapRef$current2 === void 0 ? void 0 : _wrapRef$current2.clientWidth) || 0;
+
+      setColumnRange(function (prev) {
+        var _prev2 = _slicedToArray(prev, 2),
+            start = _prev2[0],
+            end = _prev2[1];
+
+        var firstIndex = findFirstIndex(columnsOffsets, scrollLeft);
+        var lastIndex = findFirstIndex(columnsOffsets, scrollLeft + PRE_RENDER_RANGE + _wrapWidth);
+
+        if (firstIndex === start && lastIndex === end) {
+          return prev;
+        }
+
+        return [firstIndex, lastIndex + 1];
+      });
+    }
+
+    if (current === EScrollVerticalDirection.SCROLL_TO_TOP) {
+      var _wrapRef$current3;
+
+      // 往上滚动
+      var wrapHeight = ((_wrapRef$current3 = wrapRef.current) === null || _wrapRef$current3 === void 0 ? void 0 : _wrapRef$current3.clientHeight) || 0;
+      var firstIndex = Math.floor((scrollTop - PRE_RENDER_RANGE) / CELL_HEIGHT);
+
+      if (firstIndex < 0) {
+        firstIndex = 0;
+      }
+
+      var lastIndex = Math.ceil((scrollTop + wrapHeight) / CELL_HEIGHT) + 1;
+      setRowRange(function (prev) {
+        var _prev3 = _slicedToArray(prev, 2),
+            start = _prev3[0],
+            end = _prev3[1];
+
+        if (firstIndex === start && lastIndex === end) {
+          return prev;
+        }
+
+        return [firstIndex, lastIndex + 1];
+      });
+    }
+
+    if (current === EScrollVerticalDirection.SCROLL_TO_BOTTOM || current === 'init') {
+      var _wrapRef$current4;
+
+      // 往下滚动
+      var _wrapHeight = ((_wrapRef$current4 = wrapRef.current) === null || _wrapRef$current4 === void 0 ? void 0 : _wrapRef$current4.clientHeight) || 0;
+
+      var _firstIndex = Math.floor(scrollTop / CELL_HEIGHT);
+
+      var _lastIndex = Math.ceil((scrollTop + _wrapHeight + PRE_RENDER_RANGE) / CELL_HEIGHT) + 1;
+
+      setRowRange(function (prev) {
+        var _prev4 = _slicedToArray(prev, 2),
+            start = _prev4[0],
+            end = _prev4[1];
+
+        if (_firstIndex === start && _lastIndex === end) {
+          return prev;
+        }
+
+        return [_firstIndex, _lastIndex + 1];
+      });
+    }
+  }, [columnsOffsets, getScrollDirection, wrapRef]);
+  var columnLayout = useMemo(function () {
+    var columnLayout = {};
+    var left = 0;
+    columns.forEach(function (column, index) {
+      var columnWidth = columnsWidth[index] || column.defaultWidth || DEFAULT_COLUMN_WIDTH;
+      columnLayout[column.id] = {
+        width: columnWidth,
+        left: left
+      };
+      left += columnWidth;
+    });
+    return columnLayout;
+  }, [columns, columnsWidth]);
+  useEffect(function () {
+    if (columnsWidth.length === 0 && columns.length > 0) {
+      var widths = columns.map(function (_ref) {
+        var defaultWidth = _ref.defaultWidth;
+        return defaultWidth || 100;
+      });
+      setColumnsWidth(widths);
+    }
+  }, [columns, columnsWidth]);
+  useEffect(function () {
+    var _wrapRef$current5, _wrapRef$current6;
+
+    setRange(((_wrapRef$current5 = wrapRef.current) === null || _wrapRef$current5 === void 0 ? void 0 : _wrapRef$current5.scrollTop) || 0, ((_wrapRef$current6 = wrapRef.current) === null || _wrapRef$current6 === void 0 ? void 0 : _wrapRef$current6.scrollLeft) || 0); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [columnLayout, wrapRef]);
+  useEffect(function () {
+    var wrap = wrapRef.current;
+    var resizeObserver = new ResizeObserver(function (entries) {
+      var _iterator = _createForOfIteratorHelper(entries),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var entry = _step.value;
+
+          if (entry.contentRect) {
+            setRange((wrap === null || wrap === void 0 ? void 0 : wrap.scrollTop) || 0, (wrap === null || wrap === void 0 ? void 0 : wrap.scrollLeft) || 0);
+          } else if (entry.contentBoxSize) {
+            setRange((wrap === null || wrap === void 0 ? void 0 : wrap.scrollTop) || 0, (wrap === null || wrap === void 0 ? void 0 : wrap.scrollLeft) || 0);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    });
+    resizeObserver.observe(wrap);
+    return function () {
+      resizeObserver.unobserve(wrap);
+      resizeObserver.disconnect();
+    };
+  }, [wrapRef, setRange]);
+  return {
+    setRange: setRange,
+    columnRange: columnRange,
+    rowRange: rowRange,
+    setColumnsWidth: setColumnsWidth,
+    columnLayout: columnLayout,
+    columnsWidth: columnsWidth
+  };
+}

package/dist/DataPreviewTable/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ITableProps } from './interface';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<ITableProps & React.RefAttributes<HTMLDivElement>>>;
+export default _default;

package/dist/DataPreviewTable/index.js

@@ -0,0 +1,105 @@
+import classNames from 'classnames';
+import React, { forwardRef, memo, useEffect, useMemo, useRef } from 'react';
+import Progress from "../Progress";
+import ScrollArea from "../ScrollArea";
+import Body from "./components/Body";
+import Error from "./components/Body/Error";
+import SkeletonBody from "./components/Body/SkeletonBody";
+import Header from "./components/Header";
+import { CELL_HEIGHT, HEADER_HEIGHT } from "./constant";
+import useDirection from "./hooks/useDirection";
+
+function DataPreviewTable(props, ref) {
+  var _wrapRef$current2;
+
+  var _props$columns = props.columns,
+      columns = _props$columns === void 0 ? [] : _props$columns,
+      _props$datasource = props.datasource,
+      datasource = _props$datasource === void 0 ? [] : _props$datasource,
+      width = props.width,
+      height = props.height,
+      loading = props.loading,
+      dataStatus = props.dataStatus,
+      _props$errorMsg = props.errorMsg,
+      errorMsg = _props$errorMsg === void 0 ? '加载失败' : _props$errorMsg;
+  var contentHeight = useMemo(function () {
+    return datasource.length * CELL_HEIGHT + HEADER_HEIGHT;
+  }, [datasource]);
+  var wrapRef = useRef(null);
+
+  var _useDirection = useDirection(columns, wrapRef),
+      columnRange = _useDirection.columnRange,
+      rowRange = _useDirection.rowRange,
+      columnsWidth = _useDirection.columnsWidth,
+      setRange = _useDirection.setRange,
+      columnLayout = _useDirection.columnLayout,
+      setColumnsWidth = _useDirection.setColumnsWidth;
+
+  var contentWidth = useMemo(function () {
+    return columnsWidth.reduce(function (sum, width) {
+      return sum + width;
+    }, 0);
+  }, [columnsWidth]);
+  useEffect(function () {
+    if (ref) {
+      if (typeof ref === 'function') {
+        ref(wrapRef.current);
+      }
+    }
+  }, [ref]);
+  var skeletonRows = useMemo(function () {
+    var _wrapRef$current;
+
+    var rows = Math.ceil((((_wrapRef$current = wrapRef.current) === null || _wrapRef$current === void 0 ? void 0 : _wrapRef$current.clientHeight) || 0 - HEADER_HEIGHT) / CELL_HEIGHT);
+    return rows - 1 < 0 ? 0 : rows - 1; // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [wrapRef.current]);
+  return /*#__PURE__*/React.createElement(ScrollArea, {
+    ref: wrapRef,
+    style: {
+      width: width,
+      height: height,
+      willChange: 'transform'
+    },
+    onViewportScroll: function onViewportScroll(e) {
+      var _ref = e.target,
+          scrollTop = _ref.scrollTop,
+          scrollLeft = _ref.scrollLeft;
+      setRange(scrollTop, scrollLeft);
+    },
+    className: classNames(props.className, 'ald-data-preview-table', {
+      'ald-data-preview-table-show-skeleton': dataStatus === 'pending'
+    })
+  }, /*#__PURE__*/React.createElement(Progress, {
+    className: "ald-data-preview-progress",
+    loading: !!loading
+  }), /*#__PURE__*/React.createElement("div", {
+    style: {
+      height: dataStatus === 'pending' ? skeletonRows * CELL_HEIGHT + HEADER_HEIGHT : contentHeight,
+      width: contentWidth,
+      position: 'relative'
+    }
+  }, /*#__PURE__*/React.createElement(Header, {
+    columns: columns,
+    columnLayout: columnLayout,
+    setWidth: setColumnsWidth,
+    columnRange: columnRange
+  }), dataStatus === 'pending' && /*#__PURE__*/React.createElement(SkeletonBody, {
+    columns: columns,
+    columnRange: columnRange,
+    columnLayout: columnLayout,
+    rowRange: rowRange,
+    rows: skeletonRows
+  }), dataStatus === 'success' && /*#__PURE__*/React.createElement(Body, {
+    columns: columns,
+    columnRange: columnRange,
+    columnLayout: columnLayout,
+    datasource: datasource,
+    rowRange: rowRange
+  }), dataStatus === 'error' && /*#__PURE__*/React.createElement(Error, {
+    errorMsg: errorMsg,
+    wrapWidth: ((_wrapRef$current2 = wrapRef.current) === null || _wrapRef$current2 === void 0 ? void 0 : _wrapRef$current2.clientWidth) || 0,
+    contentWidth: contentWidth
+  })));
+}
+
+export default /*#__PURE__*/memo( /*#__PURE__*/forwardRef(DataPreviewTable));

package/dist/DataPreviewTable/interface.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties } from 'react';
+export interface ITableProps {
+    columns?: PreviewColumn[];
+    datasource?: TValue[][];
+    width?: CSSProperties['width'];
+    height?: CSSProperties['height'];
+    dataStatus?: 'pending' | 'success' | 'error';
+    loading?: boolean;
+    errorMsg?: string;
+    className?: string;
+}
+export interface PreviewColumn {
+    icon?: React.ReactNode;
+    name: string;
+    id: string;
+    defaultWidth?: number;
+    renderHeader?: (column: Omit<PreviewColumn, 'render'>) => React.ReactElement;
+    align?: 'left' | 'center' | 'right';
+}
+export declare type TValue = string | null | number | boolean;
+export interface IColumnLayout {
+    [key: string]: {
+        width: number;
+        left: number;
+    };
+}

package/dist/DataPreviewTable/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/DataPreviewTable/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style';
+import './index.less';

package/dist/DataPreviewTable/style/index.js

@@ -0,0 +1,2 @@
+import "../../style";
+import "./index.less";

package/dist/DataPreviewTable/style/index.less

@@ -0,0 +1,138 @@
+@import '../../style/index.less';
+@import '../../ScrollArea/style/index.less';
+@import '../../Progress/style/index.less';
+@import '../../Skeleton/style/index.less';
+
+.ald-data-preview-table {
+  border: 1px solid #d5d5d5;
+  font-size: 12px;
+  position: relative;
+
+  * {
+    box-sizing: border-box;
+  }
+}
+
+.ald-data-preview-header {
+  height: 28px;
+  z-index: 2;
+  background-color: #e9e9e9;
+  width: 100%;
+}
+
+.ald-data-preview-header-cell {
+  height: 100%;
+  position: relative;
+  border: 1px solid #d5d5d5;
+  border-left: none;
+  border-top: none;
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  color: #171717;
+  font-weight: 500;
+
+  .ald-data-preview-header-default {
+    padding: 4px 13px 3px 14px;
+    height: 100%;
+    width: 100%;
+    line-height: 20px;
+
+    .ald-data-preview-header-left {
+      width: 20px;
+      height: 20px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 16px;
+      position: absolute;
+      left: 0;
+      z-index: 1;
+      color: #575757;
+      // background:rgb(0 0 0 / 0%)
+    }
+
+    .ald-data-preview-header-name {
+      text-align: center;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .ald-data-preview-header-right {
+      width: 20px;
+      height: 20px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 16px;
+      position: absolute;
+      right: 0;
+      z-index: 1;
+    }
+  }
+}
+
+.ald-data-preview-body-cell {
+  white-space: nowrap;
+  overflow: hidden;
+  border: 1px solid #e8e8e8;
+  border-left: none;
+  border-top: none;
+  padding-left: 4px;
+  padding-top: 2px;
+  padding-bottom: 1px;
+  line-height: 16px;
+  box-sizing: border-box;
+  font-style: normal;
+  font-weight: 400;
+  text-align: left;
+}
+
+.ald-data-preview-body-skeleton-cell {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: 1px solid #e8e8e8;
+  border-left: none;
+  border-top: none;
+  padding: 2px 3px 1px 4px;
+
+  .ant-skeleton-title {
+    margin: 0;
+  }
+}
+
+.ald-data-preview-header-drag-bar {
+  height: 100%;
+  width: 3px;
+  position: absolute;
+  right: 0;
+  top: 0;
+  z-index: 2;
+
+  &:hover {
+    cursor: col-resize;
+    background-color: @B60;
+  }
+
+  &.ald-data-preview-header-drag-bar-active {
+    background-color: @B60;
+  }
+}
+
+.ald-data-preview-progress {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 3;
+}
+
+.ald-data-preview-table-error {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 16px;
+  padding: 30px;
+  position: fixed;
+}

package/dist/DataPreviewTable/utils/findRange.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param arr 有序数组
+ * @param targetNumber 当前数字
+ * @returns 数组中第一个大于等于目标数字的index，最大为arr.length-1 如果数组为空，返回-1
+ */
+export declare function findLastIndex(arr: number[], targetNumber: number): number;
+/**
+ *
+ * @param arr 有序数组
+ * @param targetNumber 当前数字
+ * @returns 返回数组中第一个小于等于目标数字的index,用于查找起始位置 ，最小为0 如果数组为空返回-1
+ */
+export declare function findFirstIndex(arr: number[], targetNumber: number): number;

package/dist/DataPreviewTable/utils/findRange.js

@@ -0,0 +1,86 @@
+import { UNDEFINED_INDEX } from "../constant";
+var FIRST_INDEX = 0;
+var BINARY_NUMBER = 2;
+/**
+ * @param arr 有序数组
+ * @param targetNumber 当前数字
+ * @returns 数组中第一个大于等于目标数字的index，最大为arr.length-1 如果数组为空，返回-1
+ */
+
+export function findLastIndex(arr, targetNumber) {
+  if (arr.length === 0) {
+    return UNDEFINED_INDEX;
+  }
+
+  var last = arr[arr.length - 1];
+
+  if (targetNumber >= last) {
+    return arr.length - 1;
+  }
+
+  var first = arr[FIRST_INDEX];
+
+  if (targetNumber <= first) {
+    return FIRST_INDEX;
+  }
+
+  var left = 0,
+      right = arr.length - 1;
+
+  while (left <= right) {
+    var midIndex = Math.floor((left + right) / BINARY_NUMBER);
+    var mid = arr[midIndex];
+
+    if (mid < targetNumber) {
+      left = midIndex + 1;
+    } else if (mid === targetNumber) {
+      return midIndex;
+    } else {
+      right = midIndex - 1;
+    }
+  }
+
+  return left;
+}
+/**
+ *
+ * @param arr 有序数组
+ * @param targetNumber 当前数字
+ * @returns 返回数组中第一个小于等于目标数字的index,用于查找起始位置 ，最小为0 如果数组为空返回-1
+ */
+
+export function findFirstIndex(arr, targetNumber) {
+  if (arr.length === 0) {
+    return UNDEFINED_INDEX;
+  }
+
+  var last = arr[arr.length - 1];
+
+  if (targetNumber >= last) {
+    return arr.length - 1;
+  }
+
+  var first = arr[FIRST_INDEX];
+
+  if (targetNumber <= first) {
+    return FIRST_INDEX;
+  }
+
+  var left = 0,
+      right = arr.length - 1;
+
+  while (left <= right) {
+    var midIndex = Math.floor((left + right) / BINARY_NUMBER);
+    var mid = arr[midIndex];
+
+    if (mid > targetNumber) {
+      right = midIndex - 1;
+    } else if (mid === targetNumber) {
+      return midIndex;
+    } else {
+      left = midIndex + 1;
+    }
+  }
+
+  return right;
+}

package/dist/DoubleCircleIcon/index.d.ts

@@ -5,6 +5,6 @@ declare const DoubleCircleIcon: (props: {
     size?: number | undefined;
     innerColor?: string | undefined;
     children: React.ReactNode;
-    type?: "error" | "warning" | "success" | "info" | undefined;
+    type?: "error" | "success" | "warning" | "info" | undefined;
 }) => JSX.Element;
 export default DoubleCircleIcon;

package/dist/Dropdown/index.js

@@ -13,7 +13,7 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
 import { Dropdown as AntdDropdown } from 'antd';
-import getPlacements from 'antd/es/_util/placements';
+import getPlacements from 'antd/lib/_util/placements';
 import classNames from 'classnames';
 import React, { useMemo } from 'react';
 import { addPopupOffset } from "../Menu";