@lemon-fe/components 0.1.82 → 0.1.85

package/es/BaseTable/index.js

@@ -0,0 +1,467 @@
+var _excluded = ["onWidthChange", "width", "fullTableRef", "children", "className"],
+    _excluded2 = ["id", "columns", "defaultColumnProps", "rowKey", "children", "summaryTitle", "summaryRecord", "dataSource", "onSortChange", "sort", "scroll", "virtual", "components", "pagination", "rowHeight", "tableLayout", "rowActions", "style", "className", "locale"];
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+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; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+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; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/// <reference path="../../typings.d.ts" />
+import React, { useMemo, useState, useEffect, useRef } from 'react';
+import { Table as AntdTable } from 'antd';
+import classNames from 'classnames';
+import { get } from 'lodash';
+import ResizeObserver from 'rc-resize-observer';
+import { isColumnType, getColumnKey } from './utils';
+import ResizeHeaderCell from './ResizeHeaderCell';
+import { PREFIX_CLS } from '../constants';
+import VirtualList from './VirtualBody';
+import BaseTableContext from './BaseTableContext';
+import Actions from './Actions';
+import empty from './empty.png';
+
+function formatSummary(summary) {
+  if (!summary) {
+    return summary;
+  }
+
+  var obj = _objectSpread({}, summary);
+
+  var pretty = new Intl.NumberFormat('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  Object.keys(obj).forEach(function (key) {
+    if (obj.hasOwnProperty(key) && typeof obj[key] === 'number') {
+      obj[key] = pretty.format(obj[key]);
+    }
+  });
+  return obj;
+}
+
+function Th(props) {
+  var onWidthChange = props.onWidthChange,
+      width = props.width,
+      fullTableRef = props.fullTableRef,
+      children = props.children,
+      className = props.className,
+      restProps = _objectWithoutProperties(props, _excluded);
+
+  var reg = /\bant-table-cell-ellipsis\b/;
+  var content = children;
+  var mClassName = className;
+
+  if (mClassName && reg.test(mClassName)) {
+    mClassName = mClassName.replace(reg, '');
+    content = /*#__PURE__*/React.createElement("div", {
+      className: "ant-table-cell-ellipsis"
+    }, content);
+  }
+
+  if (!width || !onWidthChange) {
+    return /*#__PURE__*/React.createElement("th", _objectSpread(_objectSpread({}, restProps), {}, {
+      className: mClassName
+    }), content);
+  }
+
+  return /*#__PURE__*/React.createElement(ResizeHeaderCell, {
+    width: width,
+    onChange: onWidthChange,
+    fullTableRef: fullTableRef,
+    prefixCls: "".concat(PREFIX_CLS, "-table")
+  }, /*#__PURE__*/React.createElement("th", _objectSpread(_objectSpread({}, restProps), {}, {
+    className: mClassName
+  }), content));
+}
+
+function BaseTable(props) {
+  var id = props.id,
+      columns = props.columns,
+      defaultColumnProps = props.defaultColumnProps,
+      rowKey = props.rowKey,
+      children = props.children,
+      summaryTitle = props.summaryTitle,
+      summaryRecord = props.summaryRecord,
+      _props$dataSource = props.dataSource,
+      dataSource = _props$dataSource === void 0 ? [] : _props$dataSource,
+      onSortChange = props.onSortChange,
+      defaultSort = props.sort,
+      scroll = props.scroll,
+      virtual = props.virtual,
+      componentsProp = props.components,
+      paginationProp = props.pagination,
+      rowHeight = props.rowHeight,
+      _props$tableLayout = props.tableLayout,
+      tableLayout = _props$tableLayout === void 0 ? 'fixed' : _props$tableLayout,
+      rowActions = props.rowActions,
+      style = props.style,
+      className = props.className,
+      localeProp = props.locale,
+      restProps = _objectWithoutProperties(props, _excluded2);
+
+  var fullTableRef = useRef(null);
+
+  var _useState = useState(new Map()),
+      _useState2 = _slicedToArray(_useState, 2),
+      colsState = _useState2[0],
+      setColsState = _useState2[1];
+
+  var scrollYProp = scroll === null || scroll === void 0 ? void 0 : scroll.y;
+
+  var _useState3 = useState(scrollYProp === true ? 0 : scrollYProp),
+      _useState4 = _slicedToArray(_useState3, 2),
+      scrollY = _useState4[0],
+      setScrollY = _useState4[1];
+
+  var memoHeight = useRef(0);
+  /** auto scroll y */
+
+  var calcScrollY = function calcScrollY() {
+    var wrapper = fullTableRef.current;
+
+    if (wrapper === null) {
+      return null;
+    }
+
+    var table = wrapper.querySelector('.ant-table');
+    var tableBody = wrapper.querySelector('.ant-table-body');
+
+    if (tableBody === null || table === null) {
+      return null;
+    }
+
+    var parent = wrapper.parentElement;
+
+    if (parent === null) {
+      return null;
+    }
+
+    var style = getComputedStyle(parent);
+    var contentHeight = parent.offsetHeight - (parseFloat(style.getPropertyValue('padding-top')) || 0) - (parseFloat(style.getPropertyValue('padding-bottom')) || 0);
+    var nodes = [];
+
+    if (tableBody.previousElementSibling !== null) {
+      nodes.push(tableBody.previousElementSibling);
+    }
+
+    if (tableBody.nextElementSibling !== null) {
+      nodes.push(tableBody.nextElementSibling);
+    }
+
+    if (table.nextElementSibling !== null) {
+      nodes.push(table.nextElementSibling);
+    }
+
+    contentHeight -= nodes.reduce(function (prev, dom) {
+      var cpStyle = window.getComputedStyle(dom);
+      var height = dom.offsetHeight + (parseFloat(cpStyle.getPropertyValue('margin-top')) || 0) + (parseFloat(cpStyle.getPropertyValue('margin-bottom')) || 0);
+      return prev + height;
+    }, 0);
+    return contentHeight;
+  };
+
+  var changeScrollY = function changeScrollY(height) {
+    if (height === memoHeight.current) {
+      return;
+    }
+
+    memoHeight.current = height;
+
+    if (memoHeight.current === 0) {
+      return;
+    }
+
+    setScrollY(calcScrollY() || undefined);
+  };
+
+  var hasPagination = false;
+
+  if (paginationProp !== false) {
+    hasPagination = paginationProp !== undefined && !!paginationProp.total || dataSource.length > 0;
+  }
+
+  useEffect(function () {
+    if (scrollYProp === true) {
+      setScrollY(calcScrollY() || 0);
+    }
+  }, [hasPagination]);
+  useEffect(function () {
+    if (scrollYProp !== true) {
+      setScrollY(scrollYProp);
+    }
+  }, [scrollYProp]);
+  useEffect(function () {
+    if (scrollY !== undefined && fullTableRef.current !== null) {
+      var body = fullTableRef.current.querySelector('.ant-table-body');
+
+      if (body !== null) {
+        var dataType = _typeof(scrollY);
+
+        switch (dataType) {
+          case 'string':
+            body.style.height = scrollY;
+            break;
+
+          case 'number':
+            body.style.height = scrollY + 'px';
+            break;
+
+          default:
+            body.style.height = 'auto';
+        }
+      }
+    }
+  }, [scrollY]);
+  /** resizable column */
+
+  var _useMemo = useMemo(function () {
+    var flattenCols = [];
+    var isFixedLayout = tableLayout === 'fixed';
+    var hasAutoWidthCol = false;
+
+    var traverse = function traverse(cols) {
+      var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      return cols.map(function (col, index) {
+        var currPath = [].concat(_toConsumableArray(path), [index]);
+
+        if (isColumnType(col)) {
+          var colKey = getColumnKey(col);
+
+          var nextCol = _objectSpread(_objectSpread({}, defaultColumnProps), col);
+
+          var colState = colsState.get(colKey);
+
+          if (colState && colState.width !== undefined) {
+            nextCol.width = colState.width;
+          }
+
+          if (isFixedLayout && !!nextCol.title) {
+            if (nextCol.width === undefined) {
+              nextCol.width = 160;
+            } else if (nextCol.width === 'auto') {
+              nextCol.width = undefined;
+            }
+          }
+
+          if (!nextCol.width) {
+            hasAutoWidthCol = true;
+          }
+
+          if (nextCol.width && !nextCol.fixed) {
+            if (nextCol.ellipsis === undefined) {
+              nextCol.ellipsis = true;
+            }
+
+            nextCol.onHeaderCell = function () {
+              return {
+                width: nextCol.width,
+                fullTableRef: fullTableRef,
+                onWidthChange: function onWidthChange(size) {
+                  setColsState(function (prev) {
+                    var prevItem = prev.get(colKey);
+
+                    if (prevItem !== undefined && prevItem.width === size) {
+                      return prev;
+                    }
+
+                    prevItem = _objectSpread(_objectSpread({}, prevItem), {}, {
+                      width: size
+                    });
+                    var next = new Map(prev);
+                    next.set(colKey, prevItem);
+                    return next;
+                  });
+                }
+              };
+            };
+          }
+
+          flattenCols.push(nextCol);
+          return nextCol;
+        }
+
+        return _objectSpread(_objectSpread(_objectSpread({}, defaultColumnProps), col), {}, {
+          children: traverse(col.children, currPath)
+        });
+      });
+    };
+
+    var newColumns = traverse(columns);
+
+    if (isFixedLayout && !hasAutoWidthCol) {
+      var emptyCol = {
+        title: ''
+      };
+      newColumns.push(emptyCol);
+      flattenCols.push(emptyCol);
+    }
+
+    return [newColumns, flattenCols];
+  }, [columns, colsState, tableLayout]),
+      _useMemo2 = _slicedToArray(_useMemo, 2),
+      formatedColumns = _useMemo2[0],
+      flattenColumns = _useMemo2[1];
+  /** row actions */
+
+
+  var _useMemo3 = useMemo(function () {
+    if (rowActions !== undefined) {
+      var actionCol = {
+        title: '',
+        className: "".concat(PREFIX_CLS, "-table-operator-column"),
+        width: 1,
+        fixed: 'right',
+        render: function render(_, row, index) {
+          return /*#__PURE__*/React.createElement(Actions, {
+            actions: rowActions,
+            row: row,
+            index: index
+          });
+        }
+      };
+      return [[].concat(_toConsumableArray(formatedColumns), [actionCol]), [].concat(_toConsumableArray(flattenColumns), [actionCol])];
+    }
+
+    return [formatedColumns, flattenColumns];
+  }, [rowActions, flattenColumns, formatedColumns]);
+
+  var _useMemo4 = _slicedToArray(_useMemo3, 2);
+
+  formatedColumns = _useMemo4[0];
+  flattenColumns = _useMemo4[1];
+
+  /** virtualize scroll */
+  var _useMemo5 = useMemo(function () {
+    return {
+      components: _objectSpread({
+        header: {
+          cell: Th
+        },
+        body: virtual ? {
+          wrapper: VirtualList
+        } : undefined
+      }, componentsProp)
+    };
+  }, [virtual]),
+      components = _useMemo5.components;
+  /** summary row */
+
+
+  var summary = useMemo(function () {
+    var Summary = AntdTable.Summary;
+
+    if (!summaryRecord) {
+      return undefined;
+    }
+
+    return function () {
+      var _props$rowSelection;
+
+      var data = formatSummary(summaryRecord);
+      var offset = 0;
+      return /*#__PURE__*/React.createElement(Summary, {
+        fixed: true
+      }, /*#__PURE__*/React.createElement(Summary.Row, null, ((_props$rowSelection = props.rowSelection) === null || _props$rowSelection === void 0 ? void 0 : _props$rowSelection.type) !== undefined && /*#__PURE__*/React.createElement(Summary.Cell, {
+        index: offset++
+      }), flattenColumns.map(function (item, index) {
+        var value;
+
+        if (index === 0) {
+          value = summaryTitle;
+        } else if (item.dataIndex) {
+          value = get(data, item.dataIndex);
+        }
+
+        return /*#__PURE__*/React.createElement(Summary.Cell, {
+          index: index + offset,
+          key: getColumnKey(item) || index,
+          align: item.align
+        }, value);
+      })));
+    };
+  }, [flattenColumns, summaryRecord, summaryTitle]);
+  var ctx = useMemo(function () {
+    return {
+      scrollY: scrollY,
+      rowHeight: rowHeight
+    };
+  }, [scrollY, rowHeight]);
+  var tableNode = /*#__PURE__*/React.createElement(AntdTable, _objectSpread(_objectSpread({
+    size: "small",
+    ref: fullTableRef,
+    className: classNames("".concat(PREFIX_CLS, "-table"), className),
+    columns: formatedColumns,
+    dataSource: dataSource,
+    rowKey: rowKey,
+    summary: summary,
+    components: components,
+    tableLayout: tableLayout,
+    scroll: {
+      x: (scroll === null || scroll === void 0 ? void 0 : scroll.x) || '100%',
+      y: scrollY
+    },
+    style: scrollYProp === true ? _objectSpread(_objectSpread({}, style), {}, {
+      height: '100%'
+    }) : style,
+    locale: _objectSpread({
+      emptyText: /*#__PURE__*/React.createElement("div", {
+        className: "".concat(PREFIX_CLS, "-table-empty")
+      }, /*#__PURE__*/React.createElement("img", {
+        src: empty
+      }), /*#__PURE__*/React.createElement("div", null, "\u6682\u65E0\u6570\u636E"))
+    }, localeProp)
+  }, restProps), {}, {
+    pagination: paginationProp !== false ? _objectSpread({
+      size: 'small',
+      pageSizeOptions: ['10', '20', '50', '100'],
+      showSizeChanger: true,
+      showQuickJumper: true,
+      showTotal: function showTotal(val) {
+        return "\u5171".concat(val, "\u6761");
+      },
+      defaultPageSize: 20
+    }, paginationProp) : false
+  }));
+
+  if (scrollYProp === true) {
+    tableNode = /*#__PURE__*/React.createElement(ResizeObserver, {
+      onResize: function onResize(size) {
+        changeScrollY(size.height);
+      }
+    }, tableNode);
+  }
+
+  return /*#__PURE__*/React.createElement(BaseTableContext.Provider, {
+    value: ctx
+  }, tableNode);
+}
+
+BaseTable.Summary = AntdTable.Summary;
+export default BaseTable;

package/es/BaseTable/utils.d.ts

@@ -0,0 +1,4 @@
+import { ColumnType, ColumnGroupType } from './typings';
+export declare function isColumnType<T>(col: ColumnGroupType<T> | ColumnType<T>): col is ColumnType<T>;
+export declare function getColumnKey(col: ColumnType<any>): string | number;
+export declare function randomStr(): string;

package/es/BaseTable/utils.js

@@ -0,0 +1,26 @@
+export function isColumnType(col) {
+  return col.children === undefined;
+}
+export function getColumnKey(col) {
+  if (typeof col.dataIndex === 'string' || typeof col.dataIndex === 'number') {
+    return col.dataIndex;
+  }
+
+  if (Array.isArray(col.dataIndex)) {
+    return col.dataIndex.join('-');
+  }
+
+  return col.key;
+}
+export function randomStr() {
+  var len = 8;
+  var chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz';
+  var maxPos = chars.length;
+  var pwd = '';
+
+  for (var i = 0; i < len; i += 1) {
+    pwd += chars.charAt(Math.floor(Math.random() * maxPos));
+  }
+
+  return pwd;
+}

package/es/ColorPicker/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface IColorPickerProps {
+    /** 选中的颜色，例：rgba(255, 255, 255, 0) */
+    value?: string;
+    /** 是否禁用透明度 */
+    disableAlpha?: boolean;
+    /** 颜色变化回调 */
+    onChange?: (val: string) => void;
+    /** 是否使用渐变选择器 */
+    gradientEnable?: boolean;
+}
+declare const ColorPicker: React.FC<IColorPickerProps>;
+export default ColorPicker;

package/es/ColorPicker/index.js

@@ -0,0 +1,114 @@
+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 { Tooltip } from 'antd';
+import React, { useEffect, useState } from 'react';
+import colorString from 'color-string';
+import ReactGPicker from 'react-gcolor-picker';
+import { SketchPicker } from 'react-color';
+var DEFAULT_COLORS = ['#FFD5B6', '#F5A623', '#F8E71C', '#8B572A', '#7ED321', '#417505', '#BD10E0', '#9013FE', '#456ad4', '#4A90E2', '#50E3C2', '#B8E986', '#000000', '#4A4A4A', '#9B9B9B', '#FFFFFF'];
+var DEFAULT_COLOR = 'rgba(255, 255, 255, 0)';
+
+var ColorPicker = function ColorPicker(_ref) {
+  var _ref$value = _ref.value,
+      value = _ref$value === void 0 ? DEFAULT_COLOR : _ref$value,
+      disableAlpha = _ref.disableAlpha,
+      gradientEnable = _ref.gradientEnable,
+      _onChange = _ref.onChange;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      pickerShow = _useState2[0],
+      setPickerShow = _useState2[1];
+
+  var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      hexColor = _useState4[0],
+      setHexColor = _useState4[1];
+
+  var _useState5 = useState(),
+      _useState6 = _slicedToArray(_useState5, 2),
+      alpha = _useState6[0],
+      setAlpha = _useState6[1];
+
+  useEffect(function () {
+    if (!gradientEnable) {
+      var rgbaColorArr = colorString.get.rgb(value);
+
+      if (!rgbaColorArr) {
+        rgbaColorArr = colorString.get.rgb(DEFAULT_COLOR);
+      }
+
+      setHexColor(colorString.to.hex(rgbaColorArr));
+      setAlpha(rgbaColorArr[3]);
+    }
+  }, [value]);
+
+  var handlePickerShow = function handlePickerShow() {
+    setPickerShow(function (val) {
+      return !val;
+    });
+  };
+
+  var handleColorChange = function handleColorChange(val, event) {
+    var _val$rgb$a;
+
+    event.stopPropagation();
+    _onChange === null || _onChange === void 0 ? void 0 : _onChange("rgba(".concat(val.rgb.r, ", ").concat(val.rgb.g, ", ").concat(val.rgb.b, ", ").concat((_val$rgb$a = val.rgb.a) !== null && _val$rgb$a !== void 0 ? _val$rgb$a : 1, ")"));
+  };
+
+  return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+    style: {
+      border: pickerShow ? '2px solid rgb(69, 143, 255)' : undefined
+    },
+    className: "lemon-color-picker",
+    onClick: handlePickerShow
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-color",
+    style: {
+      background: value,
+      width: gradientEnable ? '100%' : 120
+    }
+  }), !gradientEnable && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-hex"
+  }, hexColor === null || hexColor === void 0 ? void 0 : hexColor.toLocaleUpperCase()), /*#__PURE__*/React.createElement(Tooltip, {
+    placement: "topRight",
+    title: "\u989C\u8272\u7684\u900F\u660E\u5EA6\uFF0C0\u8868\u793A\u900F\u660E\uFF0C100\u8868\u793A\u4E0D\u900F\u660E"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-alpha"
+  }, Math.floor(Number(alpha) * 100), "%"))), pickerShow && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-pop",
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    }
+  }, gradientEnable ? /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-react-picker"
+  }, /*#__PURE__*/React.createElement(ReactGPicker, {
+    showAlpha: !disableAlpha,
+    value: value,
+    onChange: function onChange(v) {
+      _onChange === null || _onChange === void 0 ? void 0 : _onChange(v);
+    },
+    format: "hex",
+    gradient: true,
+    solid: false
+  })) : /*#__PURE__*/React.createElement(SketchPicker, {
+    disableAlpha: disableAlpha,
+    onChange: handleColorChange,
+    color: value,
+    presetColors: DEFAULT_COLORS
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "lemon-color-picker-mask"
+  }))));
+};
+
+export default ColorPicker;

package/es/Dropdown/index.d.ts

@@ -0,0 +1,14 @@
+import type { PopoverProps } from 'antd';
+import type { ReactElement } from 'react';
+interface Props {
+    actions: ({
+        text: string | ReactElement;
+        onClick: () => void;
+        disabled?: boolean;
+    } | null)[];
+    overlayClassName?: string;
+    placement?: PopoverProps['placement'];
+    children?: ReactElement | null;
+}
+export default function Dropdown(props: Props): JSX.Element;
+export {};