@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/HeaderRenderer.js

@@ -0,0 +1,93 @@
+var _excluded = ["title", "children"];
+
+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 _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, { useContext } from 'react';
+import { CaretUpOutlined, CaretDownOutlined } from '@ant-design/icons';
+import classNames from 'classnames';
+import { ConfigProvider } from 'antd';
+import { useGridStore } from "./hooks";
+
+function Sort(props) {
+  var value = props.value;
+  var antPrefixCls = useContext(ConfigProvider.ConfigContext).getPrefixCls('table');
+  return /*#__PURE__*/React.createElement("span", {
+    className: "".concat(antPrefixCls, "-column-sorter ").concat(antPrefixCls, "-column-sorter-full")
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(antPrefixCls, "-column-sorter-inner")
+  }, /*#__PURE__*/React.createElement(CaretUpOutlined, {
+    className: classNames("".concat(antPrefixCls, "-column-sorter-up"), {
+      active: value === 'asc'
+    })
+  }), /*#__PURE__*/React.createElement(CaretDownOutlined, {
+    className: classNames("".concat(antPrefixCls, "-column-sorter-down"), {
+      active: value === 'desc'
+    })
+  })));
+}
+
+export default function HeaderRenderer(props) {
+  var title = props.title,
+      children = props.children,
+      restProps = _objectWithoutProperties(props, _excluded);
+
+  var context = useGridStore(function (state) {
+    return state.context;
+  });
+  var content;
+
+  if (typeof title === 'function') {
+    content = title(_objectSpread(_objectSpread({}, restProps), {}, {
+      context: context
+    }));
+  } else if (title !== undefined) {
+    content = title;
+  } else {
+    content = restProps.displayName;
+  }
+
+  var handleClick;
+  var sort = null;
+  var menu = null;
+
+  if (restProps.enableSorting) {
+    handleClick = function handleClick(e) {
+      restProps.progressSort(e.metaKey || e.ctrlKey);
+    };
+
+    sort = /*#__PURE__*/React.createElement(Sort, {
+      value: restProps.column.getSort()
+    });
+  }
+
+  if (restProps.enableMenu) {
+    menu = /*#__PURE__*/React.createElement("span", {
+      onClick: function onClick(e) {
+        restProps.showColumnMenu(e.currentTarget);
+      },
+      className: "ag-header-icon ag-header-cell-menu-button",
+      "aria-hidden": "true"
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "ag-icon ag-icon-menu",
+      unselectable: "on",
+      role: "presentation"
+    }));
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "ag-cell-label-container"
+  }, menu, /*#__PURE__*/React.createElement("div", {
+    className: "ag-header-cell-label",
+    onClick: handleClick
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "ag-header-cell-text"
+  }, content), sort));
+}

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ICellEditorReactComp } from '@ag-grid-community/react';
+import type { ICellEditorParams } from '@ag-grid-community/core';
+import type { EditableRender } from '../typings';
+export interface CustomEditorParams {
+    editableRender: EditableRender<any>;
+}
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & CustomEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+export default _default;

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

@@ -0,0 +1,105 @@
+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 React, { useEffect, useRef } from 'react';
+import { forwardRef, useImperativeHandle, useState } from 'react';
+import { get } from 'lodash';
+import EditorWrapper from "./Wrapper";
+import { useGridStore } from "../hooks";
+export default /*#__PURE__*/forwardRef(function CustomEditor(props, ref) {
+  var api = props.api,
+      cellStartedEdit = props.cellStartedEdit,
+      stopEditing = props.stopEditing,
+      editableRender = props.editableRender,
+      data = props.data,
+      rowIndex = props.rowIndex,
+      field = props.colDef.field;
+
+  var _useState = useState(data),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+
+  var context = useGridStore(function (state) {
+    return state.context;
+  });
+  var elm = useRef(null);
+  useEffect(function () {
+    if (cellStartedEdit && elm.current !== null) {
+      var _elm$current = elm.current,
+          select = _elm$current.select,
+          focus = _elm$current.focus;
+
+      if (select !== undefined) {
+        select();
+      } else if (focus !== undefined) {
+        focus();
+      }
+    }
+  }, [cellStartedEdit]);
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: function getValue() {
+        return value;
+      },
+      focusIn: function focusIn() {
+        if (elm.current !== null) {
+          var _elm$current2 = elm.current,
+              focus = _elm$current2.focus,
+              select = _elm$current2.select;
+
+          if (select !== undefined) {
+            select();
+          } else if (focus !== undefined) {
+            focus();
+          }
+        }
+
+        return true;
+      },
+      focusOut: function focusOut() {
+        if (elm.current !== null) {
+          var blur = elm.current.blur;
+
+          if (blur !== undefined) {
+            blur();
+          }
+        }
+
+        return true;
+      }
+    };
+  });
+
+  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, null, editableRender(field ? get(value, field) : null, data, rowIndex, {
+    context: context,
+    ref: elm,
+    onChange: handleChange
+  }));
+});

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ICellEditorReactComp } from '@ag-grid-community/react';
+import type { ICellEditorParams } from '@ag-grid-community/core';
+export interface DateEditorParams {
+    format: string;
+}
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & DateEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+export default _default;

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

@@ -0,0 +1,78 @@
+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 React, { useEffect, useRef } from 'react';
+import { forwardRef, useImperativeHandle, useState } from 'react';
+import moment from 'moment';
+import { DatePicker } from 'antd';
+import EditorWrapper from "./Wrapper";
+import { editorPrefixClass } from "./utils";
+export default /*#__PURE__*/forwardRef(function DateEditor(props, ref) {
+  var cellStartedEdit = props.cellStartedEdit,
+      _props$format = props.format,
+      format = _props$format === void 0 ? 'YYYY-MM-DD' : _props$format;
+
+  var _useState = useState(props.value ? moment(props.value, format) : null),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+
+  var elm = useRef(null);
+  useEffect(function () {
+    if (cellStartedEdit) {
+      var _elm$current;
+
+      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.focus();
+    }
+  }, [cellStartedEdit]);
+
+  var getValue = function getValue() {
+    return value ? value.format(format) : '';
+  };
+
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: getValue,
+      focusIn: function focusIn() {
+        var _elm$current2;
+
+        (_elm$current2 = elm.current) === null || _elm$current2 === void 0 ? void 0 : _elm$current2.focus();
+        return true;
+      },
+      focusOut: function focusOut() {
+        var _elm$current3;
+
+        (_elm$current3 = elm.current) === null || _elm$current3 === void 0 ? void 0 : _elm$current3.blur();
+        return true;
+      }
+    };
+  });
+  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement(DatePicker, {
+    style: {
+      display: 'flex',
+      paddingTop: 0,
+      paddingBottom: 0
+    },
+    className: editorPrefixClass('date'),
+    value: value,
+    placeholder: format,
+    onChange: function onChange(val) {
+      if (val) {
+        setValue(val);
+      } else {
+        setValue(null);
+      }
+    },
+    ref: elm,
+    bordered: false
+  }));
+});

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ICellEditorReactComp } from '@ag-grid-community/react';
+import type { ICellEditorParams } from '@ag-grid-community/core';
+export interface NumberEditorParams {
+    min?: number;
+    max?: number;
+}
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & NumberEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+export default _default;

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

@@ -0,0 +1,86 @@
+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 React, { useEffect, useRef } from 'react';
+import { forwardRef, useImperativeHandle, useState } from 'react';
+import EditorWrapper from "./Wrapper";
+import { editorPrefixClass } from "./utils";
+export default /*#__PURE__*/forwardRef(function NumberEditor(props, ref) {
+  var _props$value;
+
+  var cellStartedEdit = props.cellStartedEdit,
+      min = props.min,
+      max = props.max;
+
+  var _useState = useState((_props$value = props.value) !== null && _props$value !== void 0 ? _props$value : null),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+
+  var elm = useRef(null);
+  useEffect(function () {
+    if (cellStartedEdit) {
+      var _elm$current;
+
+      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.select();
+    }
+  }, [cellStartedEdit]);
+
+  var getValue = function getValue() {
+    if (value === '' || value === null) {
+      return null;
+    }
+
+    var val;
+
+    if (typeof value === 'string') {
+      val = parseFloat(value);
+    } else {
+      val = value;
+    }
+
+    if (min !== undefined && val < min) {
+      val = min;
+    } else if (max !== undefined && val > max) {
+      val = max;
+    }
+
+    return val;
+  };
+
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: getValue,
+      focusIn: function focusIn() {
+        var _elm$current2;
+
+        (_elm$current2 = elm.current) === null || _elm$current2 === void 0 ? void 0 : _elm$current2.select();
+        return true;
+      },
+      focusOut: function focusOut() {
+        var _elm$current3;
+
+        (_elm$current3 = elm.current) === null || _elm$current3 === void 0 ? void 0 : _elm$current3.blur();
+        return true;
+      }
+    };
+  });
+  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement("input", {
+    type: "number",
+    className: editorPrefixClass('text'),
+    ref: elm,
+    value: value !== null && value !== void 0 ? value : '',
+    onChange: function onChange(event) {
+      return setValue(event.target.value);
+    }
+  }));
+});

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

@@ -0,0 +1,7 @@
+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, 'options' | 'fieldNames' | 'virtual' | 'showSearch' | 'listHeight' | 'listItemHeight' | 'allowClear' | 'mode' | 'labelInValue'>;
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & SelectEditorParams & React.RefAttributes<ICellEditorReactComp>>;
+export default _default;

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

@@ -0,0 +1,70 @@
+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 _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 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 stopEditing = props.stopEditing,
+      cellStartedEdit = props.cellStartedEdit,
+      cellEditorParams = props.colDef.cellEditorParams;
+
+  var _useState = useState(props.value),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+
+  var elm = useRef(null);
+  useEffect(function () {
+    if (cellStartedEdit) {
+      var _elm$current;
+
+      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.focus();
+    }
+  }, [cellStartedEdit]);
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: function getValue() {
+        return value;
+      },
+      focusIn: function focusIn() {
+        var _elm$current2;
+
+        (_elm$current2 = elm.current) === null || _elm$current2 === void 0 ? void 0 : _elm$current2.focus();
+        return true;
+      },
+      focusOut: function focusOut() {
+        var _elm$current3;
+
+        (_elm$current3 = elm.current) === null || _elm$current3 === void 0 ? void 0 : _elm$current3.blur();
+        return true;
+      }
+    };
+  });
+  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement(Select, _extends({
+    ref: elm,
+    bordered: false,
+    className: editorPrefixClass('select')
+  }, cellEditorParams, {
+    value: value,
+    onChange: function onChange(val) {
+      setValue(val);
+      requestAnimationFrame(function () {
+        stopEditing();
+      });
+    }
+  })));
+});

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ICellEditorReactComp } from '@ag-grid-community/react';
+import type { ICellEditorParams } from '@ag-grid-community/core';
+declare const _default: React.ForwardRefExoticComponent<ICellEditorParams<any, any> & React.RefAttributes<ICellEditorReactComp>>;
+export default _default;

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

@@ -0,0 +1,60 @@
+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 React, { useEffect, useRef } from 'react';
+import { forwardRef, useImperativeHandle, useState } from 'react';
+import EditorWrapper from "./Wrapper";
+import { editorPrefixClass } from "./utils";
+export default /*#__PURE__*/forwardRef(function TextEditor(props, ref) {
+  var cellStartedEdit = props.cellStartedEdit;
+
+  var _useState = useState(props.value),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+
+  var elm = useRef(null);
+  useEffect(function () {
+    if (cellStartedEdit) {
+      var _elm$current;
+
+      (_elm$current = elm.current) === null || _elm$current === void 0 ? void 0 : _elm$current.select();
+    }
+  }, [cellStartedEdit]);
+  useImperativeHandle(ref, function () {
+    return {
+      getValue: function getValue() {
+        return value;
+      },
+      focusIn: function focusIn() {
+        var _elm$current2;
+
+        (_elm$current2 = elm.current) === null || _elm$current2 === void 0 ? void 0 : _elm$current2.select();
+        return true;
+      },
+      focusOut: function focusOut() {
+        var _elm$current3;
+
+        (_elm$current3 = elm.current) === null || _elm$current3 === void 0 ? void 0 : _elm$current3.blur();
+        return true;
+      }
+    };
+  });
+  return /*#__PURE__*/React.createElement(EditorWrapper, null, /*#__PURE__*/React.createElement("input", {
+    className: editorPrefixClass('text'),
+    ref: elm,
+    value: value,
+    onChange: function onChange(event) {
+      return setValue(event.target.value);
+    }
+  }));
+});

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

@@ -0,0 +1,4 @@
+import { type ReactNode } from 'react';
+export default function EditorWrapper(props: {
+    children: ReactNode;
+}): JSX.Element;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { editorPrefixClass } from "./utils";
+export default function EditorWrapper(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: editorPrefixClass()
+  }, props.children);
+}

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

@@ -0,0 +1 @@
+export declare const editorPrefixClass: (val?: string | undefined) => string;

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

@@ -0,0 +1,2 @@
+import { prefixClassName } from "../../utils";
+export var editorPrefixClass = prefixClassName('grid-editor');

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

@@ -0,0 +1,2 @@
+import type { GridStore } from './typings';
+export declare function useGridStore<T>(getter: (state: GridStore) => T): T;

package/es/components/DataGrid/hooks.js

@@ -0,0 +1,45 @@
+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 { useContext, useEffect, useRef, useState } from 'react';
+import shallowEqual from 'shallowequal';
+import GridContext from "./GridContext";
+export function useGridStore(getter) {
+  var store = useContext(GridContext);
+  var ref = useRef(getter);
+  ref.current = getter;
+
+  var _useState = useState(getter(store.getState())),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+
+  useEffect(function () {
+    var _store$subscribe = store.subscribe({
+      next: function next(value) {
+        setState(function (prev) {
+          var next = ref.current(value);
+
+          if (shallowEqual(prev, next)) {
+            return prev;
+          }
+
+          return next;
+        });
+      }
+    }),
+        unsubscribe = _store$subscribe.unsubscribe;
+
+    return unsubscribe;
+  }, []);
+  return state;
+}