@lemon-fe/components 0.1.154 → 1.1.0-alpha.1

package/es/data-grid/typings.d.ts

@@ -0,0 +1,226 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { ColDef, ColGroupDef, EditableCallbackParams, ICellEditorParams, ICellRendererParams, IHeaderParams, AgGridEvent, CheckboxSelectionCallback, ColumnState, IRowNode } from '@ag-grid-community/core';
+import type { AgGridReactProps } from '@ag-grid-community/react';
+import type { RuleItem, ValidateFieldsError } from 'async-validator/dist-types/interface';
+import type { DateEditorParams } from './cell-editors/date';
+import type { NumberEditorParams } from './cell-editors/number';
+import type { RowEditorParams } from './cell-editors/row';
+import type { SelectEditorParams } from './cell-editors/select';
+import type { TextEditorParams } from './cell-editors/text';
+import type { FieldCol } from './components/custom-panel/typings';
+import type DataGrid from './index';
+export type { TextEditorParams } from './cell-editors/text';
+export type { NumberEditorParams } from './cell-editors/number';
+export type { DateEditorParams } from './cell-editors/date';
+export type { SelectEditorParams } from './cell-editors/select';
+export type { RowEditorParams } from './cell-editors/row';
+export type { FieldCol } from './components/custom-panel/typings';
+export declare type GetRowId<T> = string | ((data: T) => string);
+export declare type PathType = string;
+export declare type ValidateRule<T> = Pick<RuleItem, 'required' | 'message' | 'pattern' | 'min' | 'max' | 'len' | 'type'> & {
+    validator?: (rule: any, val: any, record: T) => void | Promise<void>;
+};
+export declare type ValidateResult<TData> = {
+    id: string;
+    node: IRowNode<TData>;
+    data: TData;
+    index: number;
+    fields: ValidateFieldsError;
+}[];
+interface EditorParamsType<T extends string, K extends Record<string, any>> {
+    type: T;
+    params?: K;
+    component?: string;
+}
+declare type EditorType<TData> = EditorParamsType<'text-editor', TextEditorParams<TData>> | EditorParamsType<'number-editor', NumberEditorParams<TData>> | EditorParamsType<'date-editor', DateEditorParams<TData>> | EditorParamsType<'select-editor', SelectEditorParams> | EditorParamsType<'row-editor', RowEditorParams<TData>>;
+export interface ColType<TData> extends Omit<ColDef<TData>, 'editable'> {
+    title?: ReactNode | ((params: IHeaderParams) => ReactNode);
+    dataIndex?: string;
+    className?: string;
+    /**
+     * @deprecated
+     */
+    sorter?: boolean | ((a: TData, b: TData) => number);
+    ellipsis?: boolean;
+    /**
+     * @description
+     * @en cell renderer. it should be a pure function, do not use the state from the closure but from cellContext
+     * @zh 单元格渲染函数. 需要是一个纯函数，不使用外部组件的状态变量，而是通过context引入
+     */
+    render?: (formattedValue: any, record: TData, index: number, params: ICellRendererParams) => ReactElement | string | number | null;
+    /**
+     * @description 可编辑单元格
+     */
+    editable?: {
+        enable?: (params: EditableCallbackParams<TData>) => boolean;
+        rules?: ValidateRule<TData>[];
+        valueSetter?: (val: any, data: TData) => Partial<TData>;
+        renderer: EditorType<TData> | ((params: ICellEditorParams<TData>) => EditorType<TData>);
+    };
+}
+export interface ColGroupType<T> extends Omit<ColGroupDef<T>, 'children'> {
+    title?: ReactNode | ((params: IHeaderParams) => ReactNode);
+    children: ColsType<T>;
+    key?: string;
+}
+export declare type ColsType<T> = (ColType<T> | ColGroupType<T>)[];
+export declare type RowSelectionType<T = any> = {
+    type?: 'checkbox' | 'radio';
+    selectedRowKeys?: string[];
+    /**
+     * @description 数据源更改是否保留所选项，远程模式默认开启，非远程模式默认关闭
+     */
+    preserveSelectedRowKeys?: boolean;
+    defaultSelectedRowKeys?: string[];
+    fixed?: boolean;
+    checkboxSelection?: boolean | CheckboxSelectionCallback<T>;
+    onChange?: (selectedKeys: string[], selectedRows: T[]) => void;
+};
+export declare type PaginationType = {
+    current?: number;
+    pageSize?: number;
+    defaultCurrent?: number;
+    pageSizeOptions?: string[];
+    defaultPageSize?: number;
+    total?: number;
+    onChange?: (current: number, pageSize: number) => void;
+};
+export declare type SelectionType = AgGridReactProps['rowSelection'];
+export declare type SortOrder = 'desc' | 'asc';
+export declare type SortType = {
+    field: string;
+    order: SortOrder;
+};
+export declare type DataGridState<TData> = {
+    pagination: boolean;
+    page: number;
+    pageSize: number;
+    total: number;
+    loading: boolean;
+    error?: Error;
+};
+export declare type GridStore = {
+    errors: Map<string, Map<string, string[]>>;
+    context?: any;
+    grid: DataGrid<any>;
+    fetchError?: Error;
+};
+export interface RowAction<T> {
+    /**
+     * @description 当text不为字符串时，建议加上key属性
+     */
+    text: string | ReactElement;
+    key?: string;
+    onClick?: (row: T) => void;
+    disabled?: boolean;
+    dropDown?: (RowAction<T> | null)[];
+}
+export declare type RowActionsType<T> = (RowAction<T> | null)[] | ((record: T, params: ICellRendererParams<T>) => (RowAction<T> | null)[]);
+export declare type DetailCell<TData, Params = Record<string, never>> = {
+    params?: Params;
+    /** 这是一个render函数不是组件 */
+    render: (params: ICellRendererParams<TData> & Params) => ReactNode;
+};
+export interface DataGridSearch {
+    /**
+     * @description
+     * 不传入就根据所有字符类型的列数据搜索
+     */
+    searchFields?: string[];
+    placeholder?: string;
+    /**
+     * @description
+     * 搜索后聚焦到哪个单元格，一般情况不要使用
+     */
+    focusColumn?: string;
+}
+export interface DataGridSearchRef {
+    reset: () => void;
+}
+export interface CustomColumnData {
+    fields: FieldCol[];
+    columState: ColumnState[];
+}
+export interface DataGridProps<TData> extends Omit<AgGridReactProps<TData>, 'rowSelection' | 'pagination'> {
+    dataSource?: TData[];
+    /**
+     * @description 编辑表格数据后的回调
+     * @param value
+     * @returns
+     */
+    onDataSourceChange?: (value: TData[], params: AgGridEvent<TData>) => void;
+    columns?: ColsType<TData>;
+    rowKey: GetRowId<TData>;
+    rowSelection?: RowSelectionType<TData>;
+    pagination?: boolean | PaginationType;
+    /**
+     * @description 汇总行
+     */
+    summary?: Record<string, any>[] | Record<string, any>;
+    /**
+     * @description 是否初次加载远程数据
+     */
+    autoLoad?: boolean;
+    /**
+     * @description 远程加载数据
+     * @param params
+     * @returns
+     */
+    fetch?: (params: {
+        current: number;
+        pageSize: number;
+        sort: SortType[];
+    }) => Promise<{
+        data: TData[];
+        summary?: any;
+        total?: number;
+        extra?: any;
+    }>;
+    /**
+     * @description 远程加载数据成功后的回调，extra为fetch方法返回的extra
+     * @param extra
+     * @returns
+     */
+    onLoad?: (extra: any) => void;
+    /**
+     * @description 远程加载数据loading发生变化
+     */
+    onLoading?: (loading: boolean) => void;
+    /**
+     * @description 行操作按钮组
+     */
+    rowActions?: RowActionsType<TData>;
+    /**
+     *
+     * @description 行操作列属性
+     */
+    rowActionsColDef?: ColDef<TData>;
+    /**
+     * @description 加载动画
+     */
+    loading?: boolean;
+    /**
+     * @description 封装后的master-detail使用方式，传了这个参数默认开启master-detai，仅当context和data改变才会重新渲染
+     */
+    detailCell?: DetailCell<TData, any>;
+    /**
+     * @description 没有行数据时显示的文本
+     */
+    emptyText?: string;
+    /**
+     * @description 显示底部搜索栏，只支持非远程模式
+     */
+    showSearch?: boolean | DataGridSearch;
+    /**
+     * @description 单元格是否表现成弹性盒子，从而便于垂直，此时也会导致文本ellipsis失效
+     */
+    cellDisplayFlex?: boolean;
+    /**
+     * @description 自定义列保存
+     */
+    customColumnPanelStorage?: {
+        suppressFieldValueGetter?: boolean;
+        set: (data: CustomColumnData) => Promise<void> | void;
+        get: () => Promise<CustomColumnData | null | undefined> | CustomColumnData | null | undefined;
+    };
+}

package/es/data-grid/typings.js

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

package/es/data-grid/utils.d.ts

@@ -0,0 +1,51 @@
+import type { ColType, ColGroupType, PathType } from './typings';
+import type { ColDef, ColGroupDef } from '@ag-grid-community/core';
+import { Subject } from '@lemon-fe/utils';
+export declare const prefix: (val?: string | undefined) => string;
+export declare function isColumn<T>(col: ColGroupType<T> | ColType<T>): col is ColType<T>;
+export declare function isColumnDef<T>(col: ColGroupDef<T> | ColDef<T>): col is ColDef<T>;
+export declare function getColField(col: {
+    field?: string;
+    key?: string;
+    dataIndex?: PathType;
+    colId?: string;
+}): string | undefined;
+export declare function isCustomField(id: string): boolean;
+export declare function withSyncRender(callback: (...args: any) => any): void;
+export declare class ColMethod {
+    private record;
+    private get;
+    set(col: ColType<any>, method: PathType): void;
+    reset(): void;
+    toRef: <K extends (...args: any) => any>(field: string | undefined, path: PathType) => K;
+}
+export declare class Store<T extends Record<string, any>> {
+    private state;
+    private subject;
+    constructor(initialState: T);
+    setState(value: Partial<T> | ((prevState: T) => Partial<T>)): void;
+    getState(): T;
+    subscribe(...args: Parameters<Subject<T>['subscribe']>): {
+        unsubscribe: () => void;
+    };
+}
+export declare class Selection<T> {
+    private record;
+    private keys;
+    private dirty;
+    private observers;
+    constructor(keys?: string[]);
+    flush(): readonly [string[], T[]];
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    set(id: string, data: T): void;
+    delete(id: string): void;
+    clear(): void;
+    clone(data: Map<string, T>): void;
+    isSameKeys(keys: string[]): boolean;
+    isDirty(): boolean;
+    getKeys(): string[];
+    forEach(cb: (key: string) => void): void;
+    listen(cb: (keys: string[]) => void): () => void;
+}
+export declare const columnTypes: Record<string, ColDef>;

package/es/data-grid/utils.js

@@ -0,0 +1,293 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _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 _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 _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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { prefixClassName } from "../utils";
+import CellDeleteRender from "./renderer/cell-delete-renderer";
+import CellIndexRender from "./renderer/cell-index-renderer";
+import { Subject } from '@lemon-fe/utils';
+import { get as _get, set as _set } from 'lodash';
+import moment from 'moment';
+export var prefix = prefixClassName('grid');
+export function isColumn(col) {
+  return col.children === undefined;
+}
+export function isColumnDef(col) {
+  return col.children === undefined;
+}
+export function getColField(col) {
+  return col.field || col.key || (Array.isArray(col.dataIndex) ? col.dataIndex.join('.') : col.dataIndex) || col.colId;
+}
+export function isCustomField(id) {
+  return /^\$\$field-/.test(id);
+}
+export function withSyncRender(callback) {
+  requestAnimationFrame(function () {
+    callback();
+  });
+}
+export var ColMethod = /*#__PURE__*/function () {
+  function ColMethod() {
+    var _this = this;
+    _classCallCheck(this, ColMethod);
+    _defineProperty(this, "record", {});
+    _defineProperty(this, "toRef", function (field, path) {
+      return function () {
+        var _this$get;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return (_this$get = _this.get(field, path)) === null || _this$get === void 0 ? void 0 : _this$get.apply(void 0, args);
+      };
+    });
+  }
+  _createClass(ColMethod, [{
+    key: "get",
+    value: function get(field, method) {
+      if (field === undefined) {
+        return;
+      }
+      return _get(this.record[field], method);
+    }
+  }, {
+    key: "set",
+    value: function set(col, method) {
+      var field = getColField(col);
+      if (field === undefined) {
+        return;
+      }
+      if (this.record[field] === undefined) {
+        this.record[field] = {};
+      }
+      _set(this.record[field], method, _get(col, method));
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.record = {};
+    }
+  }]);
+  return ColMethod;
+}();
+export var Store = /*#__PURE__*/function () {
+  function Store(initialState) {
+    _classCallCheck(this, Store);
+    _defineProperty(this, "state", void 0);
+    _defineProperty(this, "subject", void 0);
+    this.state = initialState;
+    this.subject = new Subject();
+  }
+  _createClass(Store, [{
+    key: "setState",
+    value: function setState(value) {
+      var result;
+      if (typeof value === 'function') {
+        result = value(this.state);
+      } else {
+        result = value;
+      }
+      this.state = _objectSpread(_objectSpread({}, this.state), result);
+      this.subject.next(this.state);
+    }
+  }, {
+    key: "getState",
+    value: function getState() {
+      return this.state;
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe() {
+      var _this$subject;
+      return (_this$subject = this.subject).subscribe.apply(_this$subject, arguments);
+    }
+  }]);
+  return Store;
+}();
+export var Selection = /*#__PURE__*/function () {
+  function Selection() {
+    var _keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, Selection);
+    _defineProperty(this, "record", void 0);
+    _defineProperty(this, "keys", void 0);
+    _defineProperty(this, "dirty", false);
+    _defineProperty(this, "observers", new Set());
+    this.record = new Map(_keys.map(function (key) {
+      return [key, null];
+    }));
+    this.keys = _keys;
+  }
+  _createClass(Selection, [{
+    key: "flush",
+    value: function flush() {
+      var _this2 = this;
+      var result = _toConsumableArray(this.record);
+      var keys = [];
+      var values = [];
+      result.forEach(function (item) {
+        keys.push(item[0]);
+        values.push(item[1]);
+      });
+      this.keys = keys;
+      this.dirty = false;
+      _toConsumableArray(this.observers).forEach(function (cb) {
+        return cb(_this2.keys);
+      });
+      return [keys, values];
+    }
+  }, {
+    key: "get",
+    value: function get(id) {
+      return this.record.get(id);
+    }
+  }, {
+    key: "has",
+    value: function has(id) {
+      return this.record.has(id);
+    }
+  }, {
+    key: "set",
+    value: function set(id, data) {
+      this.record.set(id, data);
+      this.dirty = true;
+    }
+  }, {
+    key: "delete",
+    value: function _delete(id) {
+      this.record.delete(id);
+      this.dirty = true;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.record = new Map();
+      this.dirty = true;
+    }
+  }, {
+    key: "clone",
+    value: function clone(data) {
+      this.record = data;
+      this.flush();
+    }
+  }, {
+    key: "isSameKeys",
+    value: function isSameKeys(keys) {
+      if (this.dirty) {
+        this.flush();
+      }
+      return this.keys === keys;
+    }
+  }, {
+    key: "isDirty",
+    value: function isDirty() {
+      return this.dirty;
+    }
+  }, {
+    key: "getKeys",
+    value: function getKeys() {
+      return this.keys;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(cb) {
+      this.keys.forEach(cb);
+    }
+  }, {
+    key: "listen",
+    value: function listen(cb) {
+      var _this3 = this;
+      this.observers.add(cb);
+      return function () {
+        _this3.observers.delete(cb);
+      };
+    }
+  }]);
+  return Selection;
+}();
+export var columnTypes = {
+  datetime: {
+    initialWidth: 160
+  },
+  date: {
+    initialWidth: 100,
+    valueFormatter: function valueFormatter(_ref) {
+      var value = _ref.value;
+      if (value) {
+        return moment(value).format('YYYY-MM-DD');
+      }
+      return value;
+    }
+  },
+  time: {
+    initialWidth: 100,
+    valueFormatter: function valueFormatter(_ref2) {
+      var value = _ref2.value;
+      if (value) {
+        return moment(value).format('HH:mm');
+      }
+      return value;
+    }
+  },
+  currency: {
+    headerClass: 'ag-right-aligned-header',
+    cellClass: 'ag-right-aligned-cell',
+    initialWidth: 120,
+    valueFormatter: function valueFormatter(_ref3) {
+      var value = _ref3.value;
+      if (typeof value === 'number') {
+        return value.toLocaleString('en-US', {
+          minimumFractionDigits: 2,
+          maximumFractionDigits: 2
+        });
+      }
+      return value;
+    }
+  },
+  number: {
+    headerClass: 'ag-right-aligned-header',
+    cellClass: 'ag-right-aligned-cell',
+    initialWidth: 120
+  },
+  index: {
+    colId: '$$index',
+    headerName: '序号',
+    cellRenderer: CellIndexRender,
+    initialWidth: 45,
+    suppressMenu: true,
+    valueGetter: function valueGetter(_ref4) {
+      var node = _ref4.node;
+      if (node && node.rowIndex !== null) {
+        return node.rowIndex + 1;
+      }
+      return null;
+    },
+    cellClass: prefix('center-aligned-cell'),
+    headerClass: prefix('center-aligned-header'),
+    suppressColumnsToolPanel: true,
+    spanHeaderHeight: true,
+    sortable: false,
+    lockPinned: true
+  },
+  delete: {
+    colId: '$$delete',
+    initialWidth: 30,
+    sortable: false,
+    suppressMenu: true,
+    cellRenderer: CellDeleteRender,
+    suppressColumnsToolPanel: true
+  },
+  centerAligned: {
+    cellClass: prefix('center-aligned-cell'),
+    headerClass: prefix('center-aligned-header')
+  }
+};

package/es/dropdown/index.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import { type DropDownProps } from 'antd';
+declare type TriggerType = 'click' | 'hover' | 'contextMenu';
+interface Props extends Omit<DropDownProps, 'trigger'> {
+    actions?: ({
+        text: string | ReactElement;
+        key?: string;
+        onClick?: () => void;
+        disabled?: boolean;
+    } | null)[];
+    trigger?: TriggerType | TriggerType[];
+}
+export default function Dropdown(props: Props): JSX.Element;
+export {};

package/es/dropdown/index.js

@@ -0,0 +1,42 @@
+var _excluded = ["actions", "trigger", "overlayClassName"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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; }
+import React, { useMemo } from 'react';
+import { prefixClassName } from "../utils";
+import { Dropdown as AntdDropdown } from 'antd';
+import classNames from 'classnames';
+export default function Dropdown(props) {
+  var _props$actions = props.actions,
+    actions = _props$actions === void 0 ? [] : _props$actions,
+    trigger = props.trigger,
+    overlayClassName = props.overlayClassName,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var prefixCls = prefixClassName('dropdown');
+  var defaultTrigger = actions.length > 0 ? ['click'] : undefined;
+  var defaultOverlayStyle = actions.length > 0 ? {
+    minWidth: 120
+  } : undefined;
+  var mTrigger = typeof trigger === 'string' ? [trigger] : trigger || defaultTrigger;
+  var items = useMemo(function () {
+    return actions.map(function (item, idx) {
+      if (item === null) {
+        return null;
+      }
+      return {
+        label: item.text,
+        key: item.key || idx.toString(),
+        onClick: item.onClick,
+        disabled: item.disabled
+      };
+    }).filter(Boolean);
+  }, [actions]);
+  return /*#__PURE__*/React.createElement(AntdDropdown, _extends({
+    menu: {
+      items: items
+    },
+    trigger: mTrigger,
+    overlayStyle: defaultOverlayStyle,
+    overlayClassName: classNames(prefixCls(), overlayClassName)
+  }, restProps));
+}

package/es/dropdown/index.less

@@ -0,0 +1,5 @@
+.@{prefixCls}-dropdown {
+  .@{ant-prefix}-dropdown-menu {
+    border-radius: 6px;
+  }
+}

package/es/{DurationPicker → duration-picker}/index.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="react" />
-import type { Moment } from 'moment';
 import type { RangePickerProps } from 'antd/lib/date-picker';
-declare type Value = {
+import type { Moment } from 'moment';
+export declare type DurationPickerValue = {
     type: string;
     option: string;
-    dates?: [string, string];
+    dates: string[];
 };
 declare type DateType = {
     label: string;
@@ -12,15 +12,18 @@ declare type DateType = {
 };
 declare type Option = {
     label: string;
-    value: (() => [Moment, Moment]) | null;
+    value: () => Moment[];
 };
-interface Props extends Omit<RangePickerProps, 'value' | 'onChange'> {
+interface Props extends Omit<RangePickerProps, 'value' | 'onChange' | 'disabled'> {
     prefixCls?: string;
     types: DateType[];
     options?: Option[];
     dateFormat?: string;
-    value?: Value;
-    onChange?: (value: Value) => void;
+    value?: DurationPickerValue;
+    hideType?: boolean;
+    onChange?: (value: DurationPickerValue) => void;
+    disabled?: boolean;
+    showTime?: boolean;
 }
-export default function DurationPicker(props: Props): JSX.Element;
-export {};
+declare function DurationPicker(props: Props): JSX.Element;
+export default DurationPicker;