@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/side-bar/sideBarModule.js

@@ -0,0 +1,19 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { HorizontalResizeComp } from "./sideBar/horizontalResizeComp";
+import { SideBarComp } from "./sideBar/sideBarComp";
+import { SideBarButtonsComp } from "./sideBar/sideBarButtonsComp";
+import { ToolPanelColDefService } from "./sideBar/common/toolPanelColDefService";
+export var SideBarModule = {
+  moduleName: ModuleNames.SideBarModule,
+  beans: [ToolPanelColDefService],
+  agStackComponents: [{
+    componentName: 'AgHorizontalResize',
+    componentClass: HorizontalResizeComp
+  }, {
+    componentName: 'AgSideBar',
+    componentClass: SideBarComp
+  }, {
+    componentName: 'AgSideBarButtons',
+    componentClass: SideBarButtonsComp
+  }]
+};

package/es/components/DataGrid/typings.d.ts

@@ -0,0 +1,138 @@
+import type { AgGridReactProps } from '@ag-grid-community/react';
+import type { ColDef, ColGroupDef, ICellRendererParams, IHeaderParams } from '@ag-grid-community/core';
+import type { RuleItem } from 'async-validator/dist-types/interface';
+import type { ReactElement, ReactNode, RefObject } from 'react';
+export declare type GetRowKey<T> = string | ((data: T) => string);
+export declare type PathType = string | (string | number)[];
+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 EditableRender<T> = (val: any, record: T, index: number, params: {
+    context: any;
+    ref: RefObject<{
+        select?: () => void;
+        focus?: () => void;
+        blur?: () => void;
+    }>;
+    onChange: (val: Partial<T>, action?: 'stop' | 'next') => void;
+}) => ReactNode;
+export interface ColumnType<TData> extends Omit<ColDef<TData>, 'editable'> {
+    title?: ReactNode | ((params: IHeaderParams) => ReactNode);
+    dataIndex?: PathType;
+    key?: string;
+    align?: 'left' | 'right';
+    fixed?: 'left' | 'right';
+    className?: string;
+    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 单元格渲染函数. 建议是一个纯函数，不使用闭包中的状态变量，而是通过cellContext引入
+     */
+    render?: (val: any, record: TData, index: number, params: ICellRendererParams) => ReactElement | string | number | null;
+    /**
+     * @description 可编辑单元格
+     */
+    editable?: boolean | {
+        type?: string;
+        params?: any;
+        rules?: ValidateRule<TData>[];
+        render?: EditableRender<TData>;
+        valueSetter?: (val: any, data: TData) => Partial<TData>;
+    };
+}
+export interface ColumnGroupType<T> extends Omit<ColGroupDef<T>, 'children'> {
+    title?: string | number;
+    children: ColumnsType<T>;
+    key?: string;
+}
+export declare type ColumnsType<T> = (ColumnType<T> | ColumnGroupType<T>)[];
+export declare type RowSelection<T = any> = {
+    type?: 'checkbox' | 'radio';
+    selectedRowKeys?: string[];
+    defaultSelectedRowKeys?: string[];
+    fixed?: boolean;
+    columnWidth?: number;
+    preserveSelectedRowKeys?: boolean;
+    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 = 'descend' | 'ascend' | null;
+export declare type SortType = {
+    field: string;
+    order: SortOrder;
+};
+export declare type GridStore = {
+    errors: Map<string, Map<string, string[]>>;
+    context?: any;
+};
+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: {
+    context?: any;
+}) => (RowAction<T> | null)[]);
+export interface DataGridProps<TData> extends Omit<AgGridReactProps<TData>, 'rowSelection' | 'pagination'> {
+    dataSource?: TData[];
+    /**
+     * @description 编辑表格数据后的回调
+     * @param value
+     * @returns
+     */
+    onDataSouceChange?: (value: TData[]) => void;
+    columns?: ColumnsType<TData>;
+    columnRenderMethods?: PathType[];
+    rowKey: GetRowKey<TData>;
+    rowSelection?: RowSelection<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 行操作按钮组
+     */
+    rowActions?: RowActionsType<TData>;
+}

package/es/components/DataGrid/typings.js

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

package/es/components/DataGrid/utils.d.ts

@@ -0,0 +1,43 @@
+import { Subject } from '@lemon-fe/utils';
+import type { ColumnType, ColumnGroupType, PathType } from './typings';
+import { ColDef } from '@ag-grid-community/core';
+export declare const prefix: (val?: string | undefined) => string;
+export declare function isColumnType<T>(col: ColumnGroupType<T> | ColumnType<T>): col is ColumnType<T>;
+export declare function getColField(col: {
+    field?: string;
+    key?: string;
+    dataIndex?: PathType;
+}): string | undefined;
+export declare function withSyncRender(callback: (...args: any) => any): void;
+export declare class ColMethod {
+    private record;
+    private get;
+    set(col: ColumnType<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;
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    set(id: string, data: T): void;
+    delete(id: string): void;
+    isSameKeys(keys: string[]): boolean;
+    isDirty(): boolean;
+    flush(): readonly [string[], T[]];
+    forEach(cb: (key: string) => void): void;
+    clone(data: Map<string, T>): void;
+}
+export declare const columnTypes: Record<string, ColDef>;

package/es/components/DataGrid/utils.js

@@ -0,0 +1,242 @@
+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(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 _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, 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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { Subject } from '@lemon-fe/utils';
+import { get as _get, set as _set } from 'lodash';
+import { prefixClassName } from "../utils";
+export var prefix = prefixClassName('grid');
+export function isColumnType(col) {
+  return col.children === undefined;
+}
+export function getColField(col) {
+  return col.field || col.key || (Array.isArray(col.dataIndex) ? col.dataIndex.join('.') : col.dataIndex);
+}
+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() {
+    _classCallCheck(this, Selection);
+
+    _defineProperty(this, "record", new Map());
+
+    _defineProperty(this, "keys", []);
+
+    _defineProperty(this, "dirty", false);
+  }
+
+  _createClass(Selection, [{
+    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: "isSameKeys",
+    value: function isSameKeys(keys) {
+      if (this.dirty) {
+        this.flush();
+      }
+
+      return this.keys === keys;
+    }
+  }, {
+    key: "isDirty",
+    value: function isDirty() {
+      return this.dirty;
+    }
+  }, {
+    key: "flush",
+    value: function flush() {
+      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;
+      return [keys, values];
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(cb) {
+      this.keys.forEach(cb);
+    }
+  }, {
+    key: "clone",
+    value: function clone(data) {
+      this.record = data;
+      this.flush();
+    }
+  }]);
+
+  return Selection;
+}();
+export var columnTypes = {
+  datetime: {
+    width: 150
+  },
+  date: {
+    width: 90
+  },
+  currency: {
+    headerClass: 'ag-right-aligned-header',
+    cellClass: 'ag-right-aligned-cell',
+    width: 120,
+    valueFormatter: function valueFormatter(_ref) {
+      var value = _ref.value;
+
+      if (typeof value === 'number') {
+        return value.toLocaleString('en-US', {
+          minimumFractionDigits: 2,
+          maximumFractionDigits: 2
+        });
+      }
+
+      return value;
+    }
+  },
+  numeric: {
+    headerClass: 'ag-right-aligned-header',
+    cellClass: 'ag-right-aligned-cell',
+    width: 120
+  }
+};

package/es/components/Dropdown/index.d.ts

@@ -0,0 +1,15 @@
+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;
+    trigger?: PopoverProps['trigger'];
+}
+export default function Dropdown(props: Props): JSX.Element;
+export {};

package/es/components/Dropdown/index.js

@@ -0,0 +1,55 @@
+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; }
+
+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 { Popover } from 'antd';
+import React, { useState } from 'react';
+import classNames from 'classnames';
+import { PREFIX_CLS } from "../../constants";
+export default function Dropdown(props) {
+  var actions = props.actions,
+      overlayClassName = props.overlayClassName,
+      _props$placement = props.placement,
+      placement = _props$placement === void 0 ? 'bottomRight' : _props$placement,
+      children = props.children,
+      _props$trigger = props.trigger,
+      trigger = _props$trigger === void 0 ? 'click' : _props$trigger;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      visible = _useState2[0],
+      setVisible = _useState2[1];
+
+  var prefixCls = "".concat(PREFIX_CLS, "-dropdown");
+  return /*#__PURE__*/React.createElement(Popover, {
+    trigger: trigger,
+    placement: placement,
+    visible: visible,
+    onVisibleChange: setVisible,
+    overlayClassName: classNames(prefixCls, overlayClassName),
+    content: actions.map(function (item, index) {
+      return item !== null && /*#__PURE__*/React.createElement("div", {
+        className: classNames("".concat(prefixCls, "-item"), _defineProperty({}, "".concat(prefixCls, "-item-disabled"), item.disabled)),
+        key: index,
+        onClick: function onClick() {
+          if (item.disabled) {
+            return;
+          }
+
+          setVisible(false);
+          item.onClick();
+        }
+      }, item.text);
+    })
+  }, children);
+}

package/es/components/Dropdown/index.less

@@ -0,0 +1,13 @@
+.@{prefixCls}-dropdown {
+  .popover();
+
+  &-item {
+    .popoverItem();
+
+    &-disabled {
+      color: rgba(0, 0, 0, 0.25);
+      background-color: #fff !important;
+      cursor: not-allowed;
+    }
+  }
+}

package/es/components/DurationPicker/index.d.ts

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