@lemon-fe/kits 1.0.0-21 → 1.0.0-211

package/es/components/DataGrid/cell-editors/Row.js

@@ -0,0 +1,146 @@
+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 _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 _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 React, { useEffect, useRef } from 'react';
+import { get } from 'lodash';
+import { forwardRef, useImperativeHandle, useState } from 'react';
+import EditorWrapper from "./Wrapper";
+import { useGridStore } from "../hooks";
+export var RowEditorData = /*#__PURE__*/function () {
+  function RowEditorData(data) {
+    _classCallCheck(this, RowEditorData);
+
+    _defineProperty(this, "data", void 0);
+
+    this.data = data;
+  }
+
+  _createClass(RowEditorData, [{
+    key: "getValue",
+    value: function getValue() {
+      return this.data;
+    }
+  }]);
+
+  return RowEditorData;
+}();
+export default /*#__PURE__*/forwardRef(function RowEditor(props, ref) {
+  var api = props.api,
+      suppressEnterEvent = props.suppressEnterEvent,
+      stopEditing = props.stopEditing,
+      render = props.render,
+      isCancelAfterEnd = props.isCancelAfterEnd,
+      column = props.column,
+      node = props.node,
+      field = props.colDef.field;
+  /**
+   * 不可以直接使用props.data因为可能是过期的值
+   */
+
+  var data = node.data;
+
+  var _useState = useState(props.value),
+      _useState2 = _slicedToArray(_useState, 2),
+      prevValue = _useState2[0],
+      setPrevValue = _useState2[1];
+
+  var _useState3 = useState(data),
+      _useState4 = _slicedToArray(_useState3, 2),
+      value = _useState4[0],
+      setValue = _useState4[1];
+
+  var context = useGridStore(function (state) {
+    return state.context;
+  });
+  var elm = useRef(null);
+  useEffect(function () {
+    if (elm.current !== null) {
+      if (elm.current.select !== undefined) {
+        elm.current.select();
+      } else if (elm.current.focus !== undefined) {
+        elm.current.focus();
+      }
+    }
+
+    var handler = function handler(evt) {
+      if (evt.update) {
+        setPrevValue(api.getValue(column, evt.node));
+        setValue(evt.newData);
+      }
+    };
+
+    node.addEventListener('dataChanged', handler);
+    return function () {
+      node.removeEventListener('dataChanged', handler);
+    };
+  }, []);
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: function getValue() {
+        var nextValue = prevValue;
+
+        if (field === undefined || value === data || isCancelAfterEnd !== undefined && isCancelAfterEnd(_objectSpread(_objectSpread({}, data), value), data)) {
+          return prevValue;
+        }
+
+        nextValue = get(value, field);
+
+        if (nextValue == prevValue) {
+          return prevValue;
+        }
+
+        return new RowEditorData(value);
+      }
+    };
+  });
+
+  var handleChange = function handleChange(val, action) {
+    setValue(val);
+
+    if (action !== undefined) {
+      requestAnimationFrame(function () {
+        switch (action) {
+          case 'stop':
+            stopEditing();
+            break;
+
+          case 'next':
+            api.tabToNextCell();
+        }
+      });
+    }
+  };
+
+  return /*#__PURE__*/React.createElement(EditorWrapper, {
+    onKeyDown: function onKeyDown(e) {
+      if (!suppressEnterEvent && e.key === 'Enter') {
+        api.tabToNextCell();
+      }
+    }
+  }, render(field ? get(value, field) : prevValue, value === data ? data : _objectSpread(_objectSpread({}, data), value), _objectSpread(_objectSpread({}, props), {}, {
+    context: context,
+    ref: elm,
+    onChange: handleChange
+  })));
+});

package/es/components/DataGrid/cell-editors/Select.d.ts

@@ -1,7 +1,33 @@
 import React from 'react';
 import type { ICellEditorReactComp } from '@ag-grid-community/react';
 import type { ICellEditorParams } from '@ag-grid-community/core';
-import type { SelectProps } from 'antd/lib/select';
-export declare type SelectEditorParams = Pick<SelectProps, 'disabled' | 'options' | 'fieldNames' | 'virtual' | 'showSearch' | 'listHeight' | 'listItemHeight' | 'allowClear' | 'mode' | 'labelInValue'>;
-declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & SelectEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+import type { BaseOptionType, SelectProps } from 'antd/lib/select';
+export declare type SelectEditorParams = Pick<SelectProps<any, BaseOptionType>, 'disabled' | 'options' | 'virtual' | 'showSearch' | 'listHeight' | 'allowClear' | 'mode'> & {
+    fieldNames?: {
+        label: string;
+        value: string;
+    };
+    /**
+     * 是否是用options的数组成员作为value的值，此时传入的value也应该是数组成员的类型
+     */
+    valueByOption?: boolean;
+    /**
+     * 完成选择后的单元格切换行为，默认为next
+     */
+    action?: 'next' | 'stop' | 'none';
+};
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & Pick<SelectProps<any, BaseOptionType>, "disabled" | "options" | "virtual" | "showSearch" | "listHeight" | "allowClear" | "mode"> & {
+    fieldNames?: {
+        label: string;
+        value: string;
+    } | undefined;
+    /**
+     * 是否是用options的数组成员作为value的值，此时传入的value也应该是数组成员的类型
+     */
+    valueByOption?: boolean | undefined;
+    /**
+     * 完成选择后的单元格切换行为，默认为next
+     */
+    action?: "stop" | "next" | "none" | undefined;
+} & React.RefAttributes<ICellEditorReactComp>>;
 export default _default;

package/es/components/DataGrid/cell-editors/Select.js

@@ -1,4 +1,4 @@
-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 _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(); }
 
@@ -12,16 +12,26 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
+import { useMemo } from 'react';
 import React, { useEffect, useRef } from 'react';
 import { forwardRef, useImperativeHandle, useState } from 'react';
 import { Select } from 'antd';
 import EditorWrapper from "./Wrapper";
 import { editorPrefixClass } from "./utils";
 export default /*#__PURE__*/forwardRef(function SelectEditor(props, ref) {
-  var cellStartedEdit = props.cellStartedEdit,
-      cellEditorParams = props.colDef.cellEditorParams,
-      column = props.column,
-      node = props.node;
+  var stopEditing = props.stopEditing,
+      api = props.api,
+      disabled = props.disabled,
+      options = props.options,
+      virtual = props.virtual,
+      allowClear = props.allowClear,
+      mode = props.mode,
+      fieldNames = props.fieldNames,
+      valueByOption = props.valueByOption,
+      showSearch = props.showSearch,
+      listHeight = props.listHeight,
+      _props$action = props.action,
+      action = _props$action === void 0 ? 'next' : _props$action;
 
   var _useState = useState(props.value),
       _useState2 = _slicedToArray(_useState, 2),
@@ -30,12 +40,10 @@ export default /*#__PURE__*/forwardRef(function SelectEditor(props, ref) {
 
   var elm = useRef(null);
   useEffect(function () {
-    if (cellStartedEdit) {
-      var _elm$current;
+    var _elm$current;
 
-      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.focus();
-    }
-  }, [cellStartedEdit]);
+    (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.focus();
+  }, []);
   useImperativeHandle(ref, function () {
     return {
       getValue: function getValue() {
@@ -43,15 +51,71 @@ export default /*#__PURE__*/forwardRef(function SelectEditor(props, ref) {
       }
     };
   });
-  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement(Select, _extends({
+  var val = useMemo(function () {
+    var result = value;
+
+    if (valueByOption && result !== null && fieldNames !== undefined) {
+      var formatValue = function formatValue(item) {
+        if (item instanceof Object) {
+          return item[fieldNames.value];
+        }
+
+        return item;
+      };
+
+      if (Array.isArray(result)) {
+        result = result.map(function (item) {
+          return formatValue(item);
+        });
+      } else if (_typeof(result) === 'object') {
+        result = formatValue(result);
+      }
+    }
+
+    return result;
+  }, [value]);
+
+  var nextAction = function nextAction() {
+    requestAnimationFrame(function () {
+      switch (action) {
+        case 'next':
+          api.tabToNextCell();
+          break;
+
+        case 'stop':
+          stopEditing();
+
+        case 'none':
+      }
+    });
+  };
+
+  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement(Select, {
     ref: elm,
     bordered: false,
-    className: editorPrefixClass('select')
-  }, cellEditorParams, {
-    value: value,
-    onChange: function onChange(val) {
-      setValue(val);
-      node.setDataValue(column, val);
+    fieldNames: fieldNames,
+    disabled: disabled,
+    virtual: virtual,
+    allowClear: allowClear,
+    showSearch: showSearch,
+    mode: mode,
+    className: editorPrefixClass('select'),
+    value: val,
+    options: options,
+    listHeight: listHeight,
+    style: {
+      width: '100%'
+    },
+    onChange: function onChange(changedValue, opt) {
+      if (valueByOption) {
+        setValue(opt);
+      } else {
+        setValue(changedValue);
+      }
+
+      if (mode === undefined) {
+        nextAction();
+      }
     }
-  })));
+  }));
 });

package/es/components/DataGrid/cell-editors/Text.d.ts

@@ -1,8 +1,10 @@
-import React from 'react';
-import type { ICellEditorReactComp } from '@ag-grid-community/react';
 import type { ICellEditorParams } from '@ag-grid-community/core';
-export interface TextEditorParams {
-    disabled: boolean;
+import type { ICellEditorReactComp } from '@ag-grid-community/react';
+import React from 'react';
+export interface TextEditorParams<TData = any> {
+    disabled?: boolean;
+    maxLength?: number;
+    isCancelAfterEnd?: (newValue: string, data: TData) => boolean;
 }
-declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & TextEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any, any> & TextEditorParams<any> & React.RefAttributes<ICellEditorReactComp>>;
 export default _default;

package/es/components/DataGrid/cell-editors/Text.js

@@ -1,3 +1,9 @@
+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; }
+
 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."); }
@@ -10,35 +16,75 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-import React, { useEffect, useRef } from 'react';
+import { message } from 'antd';
+import React, { useEffect, useMemo, useRef } from 'react';
 import { forwardRef, useImperativeHandle, useState } from 'react';
 import EditorWrapper from "./Wrapper";
-import { editorPrefixClass } from "./utils";
+import { editorPrefixClass, navigateCell } from "./utils";
 export default /*#__PURE__*/forwardRef(function TextEditor(props, ref) {
-  var cellStartedEdit = props.cellStartedEdit,
-      disabled = props.disabled;
+  var disabled = props.disabled,
+      maxLength = props.maxLength,
+      _isCancelAfterEnd = props.isCancelAfterEnd,
+      data = props.data,
+      headerName = props.colDef.headerName;
+
+  var _useMemo = useMemo(function () {
+    if (props.eventKey === 'BackSpace') {
+      return ['', false];
+    }
+
+    if (props.charPress) {
+      return [props.charPress, false];
+    }
+
+    return [props.value, true];
+  }, []),
+      _useMemo2 = _slicedToArray(_useMemo, 2),
+      defaultValue = _useMemo2[0],
+      shouldSelect = _useMemo2[1];
 
-  var _useState = useState(props.value),
+  var _useState = useState(defaultValue),
       _useState2 = _slicedToArray(_useState, 2),
       value = _useState2[0],
       setValue = _useState2[1];
 
   var elm = useRef(null);
   useEffect(function () {
-    if (cellStartedEdit) {
-      var _elm$current;
+    if (elm.current === null) {
+      return;
+    }
 
-      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.select();
+    elm.current.focus();
+
+    if (shouldSelect) {
+      elm.current.select();
     }
-  }, [cellStartedEdit]);
+  }, []);
   useImperativeHandle(ref, function () {
     return {
+      isCancelAfterEnd: function isCancelAfterEnd() {
+        if (maxLength && (value || '').length > maxLength) {
+          message.warning("".concat(headerName || '', "\u6700\u591A").concat(maxLength, "\u4E2A\u5B57\u7B26"));
+          return true;
+        }
+
+        if (_isCancelAfterEnd !== undefined) {
+          return _isCancelAfterEnd(value, data);
+        }
+
+        return false;
+      },
       getValue: function getValue() {
         return value;
       }
     };
   });
   return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement("input", {
+    onKeyDown: function onKeyDown(e) {
+      navigateCell(_objectSpread(_objectSpread({}, props), {}, {
+        event: e
+      }));
+    },
     disabled: disabled,
     className: editorPrefixClass('text'),
     ref: elm,

package/es/components/DataGrid/cell-editors/Wrapper.d.ts

@@ -1,4 +1,5 @@
-import { type ReactNode } from 'react';
+import { type ReactNode, type KeyboardEventHandler } from 'react';
 export default function EditorWrapper(props: {
     children: ReactNode;
+    onKeyDown?: KeyboardEventHandler<HTMLDivElement>;
 }): JSX.Element;

package/es/components/DataGrid/cell-editors/Wrapper.js

@@ -1,7 +1,9 @@
+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); }
+
 import React from 'react';
 import { editorPrefixClass } from "./utils";
 export default function EditorWrapper(props) {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React.createElement("div", _extends({
     className: editorPrefixClass()
-  }, props.children);
+  }, props));
 }

package/es/components/DataGrid/cell-editors/utils.d.ts

@@ -1 +1,10 @@
+import type { Column, ColumnApi, GridApi, IRowNode } from '@ag-grid-community/core';
+import type { KeyboardEvent } from 'react';
 export declare const editorPrefixClass: (val?: string | undefined) => string;
+export declare function navigateCell(params: {
+    api: GridApi;
+    columnApi: ColumnApi;
+    event: KeyboardEvent;
+    node: IRowNode;
+    column: Column;
+}): void;

package/es/components/DataGrid/cell-editors/utils.js

@@ -1,2 +1,57 @@
 import { prefixClassName } from "../../utils";
-export var editorPrefixClass = prefixClassName('grid-editor');
+export var editorPrefixClass = prefixClassName('grid-editor');
+export function navigateCell(params) {
+  var api = params.api,
+      event = params.event,
+      node = params.node,
+      column = params.column,
+      columnApi = params.columnApi;
+
+  if (event.key === 'Enter') {
+    api.tabToNextCell();
+    return;
+  }
+
+  if (node.rowIndex === null) {
+    return;
+  }
+
+  var columns = columnApi.getAllDisplayedColumns();
+  var nextColumnIndex = columns.findIndex(function (item) {
+    return item === column;
+  });
+
+  if (nextColumnIndex < 0) {
+    return;
+  }
+
+  var nextRowIndex = node.rowIndex;
+  var renderedRowCount = api.getModel().getRowCount();
+
+  switch (event.key) {
+    case 'ArrowUp':
+      nextRowIndex -= 1;
+      break;
+
+    case 'ArrowRight':
+      nextColumnIndex += 1;
+      break;
+
+    case 'ArrowDown':
+      nextRowIndex += 1;
+      break;
+
+    case 'ArrowLeft':
+      nextColumnIndex -= 1;
+      break;
+
+    default:
+      return;
+  }
+
+  if (nextRowIndex < 0 || nextRowIndex >= renderedRowCount || nextColumnIndex < 0 || nextColumnIndex >= columns.length) {
+    return;
+  }
+
+  api.setFocusedCell(nextRowIndex, columns[nextColumnIndex]);
+}

package/es/components/DataGrid/components/CustomColumnPanel/DragContext.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { DragActive } from './typings';
+declare const DragContext: import("react").Context<DragActive | undefined>;
+export default DragContext;

package/es/components/DataGrid/components/CustomColumnPanel/DragContext.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+var DragContext = /*#__PURE__*/createContext(undefined);
+export default DragContext;

package/es/components/DataGrid/components/CustomColumnPanel/FieldModal.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { FieldCol, Node } from './typings';
+interface Props {
+    open?: boolean | FieldCol;
+    onCancel: () => void;
+    onOk: (field: FieldCol) => void;
+    nodes: Node[];
+}
+export default function FieldModal(props: Props): JSX.Element;
+export {};