@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/index.js

@@ -0,0 +1,1051 @@
+var _excluded = ["validator"],
+    _excluded2 = ["title", "key", "dataIndex", "align", "type", "fixed", "render", "ellipsis", "cellRenderer", "cellRendererParams", "className", "sorter", "editable"],
+    _excluded3 = ["title", "children"],
+    _excluded4 = ["rowSelection", "rowKey", "fetch", "dataSource", "summary", "rowActions", "context", "onGridReady", "pagination", "defaultColDef"];
+
+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 _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return generator._invoke = function (innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; }(innerFn, self, context), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; this._invoke = function (method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); }; } function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (undefined === method) { if (context.delegate = null, "throw" === context.method) { if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) { if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; } return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (object) { var keys = []; for (var key in object) { keys.push(key); } return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); } }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _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 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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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, { Component } from 'react';
+import { AgGridReact } from '@ag-grid-community/react';
+import shallowEqual from 'shallowequal';
+import { ModuleRegistry, GridApi, ColumnApi } from '@ag-grid-community/core';
+import { InfiniteRowModelModule } from '@ag-grid-community/infinite-row-model';
+import { get, set } from 'lodash';
+import Scheme from 'async-validator';
+import GridContext from "./GridContext";
+import { RowGroupingModule } from "./modules/row-grouping";
+import { ClipboardModule } from "./modules/clipboard";
+import { MenuModule } from "./modules/menu";
+import { ColumnsToolPanelModule } from "./modules/column-tool-panel";
+import { SideBarModule } from "./modules/side-bar";
+import { ServerSideRowModelModule } from "./modules/server-side-row-model";
+import { ClientSideRowModelModule } from "./modules/client-side-row-model";
+import { Spin, Pagination } from 'antd';
+import { prefix, getColField, isColumnType, withSyncRender, ColMethod, Store, Selection, columnTypes } from "./utils";
+import HeaderRenderer from "./HeaderRenderer";
+import CellRenderer from "./CellRenderer";
+import Actions from "./Actions";
+import DateEditor from "./cell-editors/Date";
+import TextEditor from "./cell-editors/Text";
+import NumberEditor from "./cell-editors/Number";
+import SelectEditor from "./cell-editors/Select";
+import Custom from "./cell-editors/Custom";
+import EditorWrapper from "./cell-editors/Wrapper";
+import empty from "./empty.png";
+ModuleRegistry.registerModules([ClientSideRowModelModule, RowGroupingModule, InfiniteRowModelModule, ClipboardModule, MenuModule, SideBarModule, ColumnsToolPanelModule, ServerSideRowModelModule], false);
+var defaultColDef = {
+  resizable: true,
+  width: 160,
+  sortable: true,
+  suppressMenu: true
+};
+
+var DataGrid = /*#__PURE__*/function (_Component) {
+  _inherits(DataGrid, _Component);
+
+  var _super = _createSuper(DataGrid);
+
+  function DataGrid(props) {
+    var _this;
+
+    _classCallCheck(this, DataGrid);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "api", new GridApi());
+
+    _defineProperty(_assertThisInitialized(_this), "selected", new Selection());
+
+    _defineProperty(_assertThisInitialized(_this), "columnApi", new ColumnApi());
+
+    _defineProperty(_assertThisInitialized(_this), "colRenderer", new ColMethod());
+
+    _defineProperty(_assertThisInitialized(_this), "store", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "dataSource", []);
+
+    _defineProperty(_assertThisInitialized(_this), "validator", null);
+
+    _defineProperty(_assertThisInitialized(_this), "requestId", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "isReady", false);
+
+    _defineProperty(_assertThisInitialized(_this), "emptyRowData", []);
+
+    _defineProperty(_assertThisInitialized(_this), "init", function (args) {
+      var api = args.api,
+          columnApi = args.columnApi;
+      _this.api = api;
+      _this.columnApi = columnApi;
+      _this.isReady = true;
+      var _this$props = _this.props,
+          onGridReady = _this$props.onGridReady,
+          autoLoad = _this$props.autoLoad;
+
+      if (onGridReady !== undefined) {
+        onGridReady(args);
+      }
+
+      if (_this.isClientMode()) {
+        _this.syncRowData();
+      } else if (autoLoad) {
+        _this.getDataFromServer();
+      }
+
+      api.addEventListener('sortChanged', function (evt) {
+        _this.sort(evt);
+      }); // 用于同步selection
+
+      api.addEventListener('rowSelected', function (_ref) {
+        var node = _ref.node;
+        var rowSelection = _this.props.rowSelection;
+
+        if (rowSelection !== undefined && node.id !== undefined && node.data !== undefined && api.getRowNode(node.id) !== undefined) {
+          var prevSelected = _this.selected.has(node.id);
+
+          var currSelected = node.isSelected();
+
+          if (currSelected !== prevSelected) {
+            if (currSelected) {
+              _this.selected.set(node.id, node.data);
+            } else {
+              _this.selected.delete(node.id);
+            }
+          }
+        }
+      });
+      api.addEventListener('selectionChanged', function () {
+        var rowSelection = _this.props.rowSelection;
+
+        if (_this.selected.isDirty() && rowSelection !== undefined && rowSelection.onChange !== undefined) {
+          var result = _this.selected.flush();
+
+          rowSelection.onChange(result[0], result[1].filter(Boolean));
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getRowId", function (params) {
+      var rowKey = _this.props.rowKey;
+      return typeof rowKey === 'function' ? rowKey(params.data) : get(params.data, rowKey);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "cellValueChanged", function (evt) {
+      var onDataSouceChange = _this.props.onDataSouceChange;
+
+      if (onDataSouceChange !== undefined) {
+        onDataSouceChange(_this.dataSource || []);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "cellEditingStop", function (evt) {
+      var data = evt.data;
+
+      _this.validateRecord(data);
+    });
+
+    _this.state = _objectSpread({
+      colDefs: _this.getColumDefs()
+    }, _this.getPagination());
+    _this.store = new Store({
+      errors: new Map(),
+      context: props.context
+    });
+    var _props$rowSelection = props.rowSelection;
+    _props$rowSelection = _props$rowSelection === void 0 ? {} : _props$rowSelection;
+    var _props$rowSelection$s = _props$rowSelection.selectedRowKeys,
+        selectedRowKeys = _props$rowSelection$s === void 0 ? [] : _props$rowSelection$s;
+    selectedRowKeys.forEach(function (key) {
+      _this.selected.set(key, null);
+    });
+
+    _this.syncColRender();
+
+    return _this;
+  }
+
+  _createClass(DataGrid, [{
+    key: "getPagination",
+    value: function getPagination() {
+      var _this$props2 = this.props,
+          pagination = _this$props2.pagination,
+          fetch = _this$props2.fetch;
+      var page = 1;
+      var pageSize = 20;
+      var total = 0;
+      var enable = false;
+
+      if (_typeof(pagination) === 'object') {
+        enable = true;
+        pageSize = pagination.defaultPageSize || pagination.pageSize || 20;
+        page = pagination.defaultCurrent || pagination.current || 1;
+        total = pagination.total || 0;
+      } else if (pagination === true) {
+        enable = true;
+      } else if (pagination === false) {
+        enable = false;
+        total = Number.MAX_SAFE_INTEGER;
+        pageSize = Number.MAX_SAFE_INTEGER;
+      } else if (fetch !== undefined) {
+        enable = true;
+      }
+
+      return {
+        pagination: enable,
+        page: page,
+        pageSize: pageSize,
+        total: total
+      };
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _prevProps$rowSelecti;
+
+      var _this$props3 = this.props,
+          columns = _this$props3.columns,
+          rowSelection = _this$props3.rowSelection,
+          dataSource = _this$props3.dataSource,
+          context = _this$props3.context;
+
+      if (columns !== prevProps.columns) {
+        this.syncColRender();
+      }
+
+      if ((rowSelection === null || rowSelection === void 0 ? void 0 : rowSelection.selectedRowKeys) !== ((_prevProps$rowSelecti = prevProps.rowSelection) === null || _prevProps$rowSelecti === void 0 ? void 0 : _prevProps$rowSelecti.selectedRowKeys)) {
+        this.syncSelection();
+      }
+
+      if (dataSource !== prevProps.dataSource) {
+        this.syncRowData();
+      }
+
+      if (!shallowEqual(context, prevProps.context)) {
+        this.store.setState({
+          context: context
+        });
+      }
+    }
+  }, {
+    key: "syncColRender",
+    value: function syncColRender() {
+      var _this2 = this;
+
+      var _this$props4 = this.props,
+          _this$props4$columns = _this$props4.columns,
+          columns = _this$props4$columns === void 0 ? [] : _this$props4$columns,
+          _this$props4$columnRe = _this$props4.columnRenderMethods,
+          columnRenderMethods = _this$props4$columnRe === void 0 ? ['title', 'render', 'editable.render'] : _this$props4$columnRe;
+      this.colRenderer.reset();
+      var descriptor = Object.create(null);
+
+      var traverse = function traverse(cols) {
+        cols.forEach(function (item) {
+          columnRenderMethods.forEach(function (path) {
+            _this2.colRenderer.set(item, path);
+          });
+          var rules = get(item, ['editable', 'rules']);
+
+          if (rules !== undefined) {
+            var id = getColField(item);
+
+            if (id !== undefined) {
+              descriptor[id] = rules.map(function (rule) {
+                var validator = rule.validator,
+                    restRule = _objectWithoutProperties(rule, _excluded);
+
+                return _objectSpread(_objectSpread({}, restRule), {}, {
+                  asyncValidator: validator ? function (mRule, value, _, record) {
+                    return validator(mRule, value, record);
+                  } : undefined,
+                  validator: undefined
+                });
+              });
+            }
+          }
+
+          if (!isColumnType(item)) {
+            traverse(item.children);
+          }
+        });
+      };
+
+      traverse(columns);
+
+      if (Object.keys(descriptor).length > 0) {
+        this.validator = new Scheme(descriptor);
+      } else {
+        this.validator = null;
+      }
+    }
+  }, {
+    key: "syncSelection",
+    value: function syncSelection() {
+      var _this3 = this;
+
+      var _this$props$rowSelect = this.props.rowSelection;
+      _this$props$rowSelect = _this$props$rowSelect === void 0 ? {} : _this$props$rowSelect;
+      var selectedRowKeys = _this$props$rowSelect.selectedRowKeys;
+
+      if (selectedRowKeys !== undefined && !this.selected.isSameKeys(selectedRowKeys)) {
+        var newSelected = new Map();
+        this.selected.forEach(function (id) {
+          var node = _this3.api.getRowNode(id);
+
+          if (node !== undefined) {
+            node.setSelected(false, false, true);
+          }
+        });
+        selectedRowKeys.forEach(function (id) {
+          newSelected.set(id, _this3.selected.get(id) || null);
+
+          var node = _this3.api.getRowNode(id);
+
+          if (node !== undefined) {
+            node.setSelected(true, false, true);
+          }
+        });
+        this.selected.clone(newSelected);
+        this.api.dispatchEvent({
+          type: 'selectionChanged'
+        });
+      }
+    }
+  }, {
+    key: "syncRowData",
+    value: function syncRowData() {
+      var dataSource = this.props.dataSource;
+
+      if (dataSource !== undefined && dataSource !== this.dataSource) {
+        this.setState({
+          total: dataSource.length
+        });
+        this.updateRowData(dataSource);
+      }
+    }
+  }, {
+    key: "getColumDefs",
+    value: function getColumDefs() {
+      var _this4 = this;
+
+      var _this$props5 = this.props,
+          _this$props5$columns = _this$props5.columns,
+          columns = _this$props5$columns === void 0 ? [] : _this$props5$columns,
+          rowActions = _this$props5.rowActions;
+
+      var map = function map(cols) {
+        return cols.map(function (item) {
+          var field = getColField(item);
+
+          if (isColumnType(item)) {
+            var _title = item.title,
+                key = item.key,
+                dataIndex = item.dataIndex,
+                align = item.align,
+                type = item.type,
+                fixed = item.fixed,
+                render = item.render,
+                _item$ellipsis = item.ellipsis,
+                ellipsis = _item$ellipsis === void 0 ? true : _item$ellipsis,
+                cellRenderer = item.cellRenderer,
+                cellRendererParams = item.cellRendererParams,
+                className = item.className,
+                sorter = item.sorter,
+                editable = item.editable,
+                _rest = _objectWithoutProperties(item, _excluded2);
+
+            var _opts = {
+              cellClass: className,
+              pinned: fixed,
+              lockPinned: true,
+              field: field,
+              type: type,
+              cellRenderer: cellRenderer,
+              cellRendererParams: cellRendererParams
+            }; // title
+
+            if (_typeof(_title) === 'object' || typeof _title === 'function') {
+              _opts.headerComponentParams = _objectSpread(_objectSpread({}, _opts.headerComponentParams), {}, {
+                title: typeof _title === 'function' ? _this4.colRenderer.toRef(field, 'title') : _title
+              });
+            } else if (_title !== undefined) {
+              _opts.headerName = _title.toString();
+            } // align
+
+
+            if (align === 'right') {
+              if (!_opts.type) {
+                _opts.type = [];
+              }
+
+              if (!Array.isArray(_opts.type)) {
+                _opts.type = [_opts.type];
+              }
+
+              _opts.type = [].concat(_toConsumableArray(_opts.type), ['rightAligned']);
+            } // render
+
+
+            if (!_opts.cellRenderer && render) {
+              _opts.cellRenderer = CellRenderer;
+              _opts.cellRendererParams = _objectSpread(_objectSpread({}, _opts.cellRendererParams), {}, {
+                render: _this4.colRenderer.toRef(field, 'render')
+              });
+            } // ellipsis
+
+
+            if (!ellipsis) {
+              _opts.wrapText = true;
+              _opts.autoHeight = true;
+            } // sorter
+
+
+            if (sorter) {
+              _opts.sortable = true;
+
+              if (typeof sorter === 'function') {
+                _opts.comparator = function (_1, _2, nodeA, nodeB) {
+                  return sorter(nodeA.data, nodeB.data);
+                };
+              }
+            } else {
+              _opts.sortable = false;
+            } // editable
+
+
+            if (_typeof(editable) === 'object') {
+              var _type = editable.type,
+                  params = editable.params,
+                  _render = editable.render,
+                  valueSetter = editable.valueSetter;
+              _opts.editable = true;
+              _opts.cellClassRules = _defineProperty({}, prefix('editor-cell'), function () {
+                return true;
+              });
+
+              if (_opts.cellRenderer === undefined) {
+                _opts.cellRenderer = CellRenderer;
+              }
+
+              if (_opts.valueSetter === undefined && valueSetter !== undefined) {
+                _opts.valueSetter = function (mParams) {
+                  var field = mParams.colDef.field,
+                      data = mParams.data,
+                      newValue = mParams.newValue;
+
+                  if (field) {
+                    set(data, field, newValue);
+                  }
+
+                  var result = valueSetter(mParams.newValue, mParams.data);
+                  Object.assign(data, result);
+                  return true;
+                };
+              }
+
+              switch (_type) {
+                case 'text':
+                  _opts.cellEditor = TextEditor;
+                  _opts.cellEditorParams = params;
+                  break;
+
+                case 'number':
+                  _opts.cellEditor = NumberEditor;
+                  _opts.cellEditorParams = params;
+                  break;
+
+                case 'date':
+                  _opts.cellEditor = DateEditor;
+                  _opts.cellEditorParams = params;
+
+                  _opts.suppressKeyboardEvent = function (_ref2) {
+                    var editing = _ref2.editing,
+                        event = _ref2.event;
+
+                    if (editing && event.key === 'Enter') {
+                      return true;
+                    }
+
+                    return false;
+                  };
+
+                  break;
+
+                case 'select':
+                  _opts.cellEditor = SelectEditor;
+                  _opts.cellEditorParams = params;
+
+                  _opts.suppressKeyboardEvent = function (_ref3) {
+                    var editing = _ref3.editing,
+                        event = _ref3.event;
+
+                    if (editing && event.key === 'Enter') {
+                      return true;
+                    }
+
+                    return false;
+                  };
+
+                  break;
+
+                default:
+                  if (_render !== undefined) {
+                    _opts.cellEditor = Custom;
+                    _opts.cellEditorParams = _objectSpread(_objectSpread({}, params), {}, {
+                      editableRender: _this4.colRenderer.toRef(field, 'editable.render')
+                    });
+
+                    if (_opts.valueSetter === undefined) {
+                      _opts.valueSetter = function (mParams) {
+                        Object.assign(mParams.data, mParams.newValue);
+                        return true;
+                      };
+                    }
+                  }
+
+              }
+            } else {
+              _opts.editable = editable;
+            }
+
+            return _objectSpread(_objectSpread({}, _opts), _rest);
+          }
+
+          var title = item.title,
+              _item$children = item.children,
+              children = _item$children === void 0 ? [] : _item$children,
+              rest = _objectWithoutProperties(item, _excluded3);
+
+          var opts = {
+            children: map(children)
+          };
+
+          if (title !== undefined) {
+            opts.headerName = title.toString();
+          }
+
+          return _objectSpread(_objectSpread({}, opts), rest);
+        });
+      };
+
+      var result = map(columns);
+      var rowSelection = this.props.rowSelection;
+
+      if (rowSelection !== undefined && result.length > 0) {
+        result[0] = _objectSpread(_objectSpread({
+          checkboxSelection: true,
+          showDisabledCheckboxes: true,
+          headerCheckboxSelection: rowSelection.type !== 'radio'
+        }, result[0]), {}, {
+          headerComponent: HeaderRenderer
+        });
+      }
+
+      if (rowActions !== undefined) {
+        result.push({
+          colId: '__actions__',
+          pinned: 'right',
+          cellRenderer: CellRenderer,
+          width: 1,
+          maxWidth: 1,
+          headerName: '',
+          resizable: false,
+          sortable: false,
+          suppressAutoSize: true,
+          suppressMovable: true,
+          lockPinned: true,
+          lockVisible: true,
+          cellClass: prefix('operator-cell'),
+          headerClass: prefix('operator-cell'),
+          cellRendererParams: {
+            render: function render(_, data) {
+              var rowActions = _this4.props.rowActions;
+
+              if (rowActions !== undefined) {
+                return /*#__PURE__*/React.createElement(Actions, {
+                  data: data,
+                  actions: rowActions
+                });
+              }
+
+              return null;
+            }
+          }
+        });
+      }
+
+      return result;
+    }
+  }, {
+    key: "isClientMode",
+    value: function isClientMode() {
+      return this.props.dataSource !== undefined;
+    }
+  }, {
+    key: "updateRowData",
+    value: function updateRowData() {
+      var _this5 = this;
+
+      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      this.dataSource = data;
+      this.api.setRowData(data);
+      this.api.forEachNode(function (node) {
+        if (node.id && _this5.selected.has(node.id)) {
+          node.setSelected(true, false, true);
+        }
+      });
+      this.api.dispatchEvent({
+        type: 'selectionChanged'
+      });
+    }
+  }, {
+    key: "getDataFromServer",
+    value: function getDataFromServer() {
+      var _this6 = this;
+
+      var fetch = this.props.fetch;
+
+      if (typeof fetch === 'function') {
+        if (this.requestId < Number.MAX_SAFE_INTEGER) {
+          this.requestId += 1;
+        }
+
+        var _this$state = this.state,
+            page = _this$state.page,
+            pageSize = _this$state.pageSize;
+        var columnState = this.columnApi.getColumnState();
+        var id = this.requestId;
+        this.api.showLoadingOverlay();
+        fetch({
+          current: page,
+          pageSize: pageSize,
+          sort: columnState.filter(function (item) {
+            return item.sort !== undefined && item.sort !== null;
+          }).map(function (item) {
+            return {
+              field: item.colId,
+              order: item.sort === 'desc' ? 'descend' : 'ascend'
+            };
+          })
+        }).then(function (res) {
+          _this6.api.hideOverlay();
+
+          if (id !== _this6.requestId) {
+            return;
+          }
+
+          if (res.total !== undefined) {
+            _this6.setState({
+              page: page,
+              pageSize: pageSize,
+              total: res.total
+            });
+          }
+
+          var _this6$props = _this6.props,
+              summary = _this6$props.summary,
+              onLoad = _this6$props.onLoad;
+          var pinned = [];
+
+          if (summary !== undefined) {
+            if (Array.isArray(summary)) {
+              pinned = summary;
+            } else {
+              pinned.push(summary);
+            }
+          }
+
+          if (res.summary !== undefined && res.summary !== null) {
+            pinned.push(res.summary);
+          } // 重置滚动条
+
+
+          _this6.api.setRowData([]);
+
+          _this6.api.setPinnedBottomRowData(pinned);
+
+          _this6.updateRowData(res.data);
+
+          if (onLoad) {
+            onLoad(res.extra);
+          }
+        }).catch(function () {
+          _this6.api.hideOverlay();
+        });
+      }
+    }
+  }, {
+    key: "sort",
+    value: function sort(evt) {
+      if (this.isClientMode()) {
+        var model = this.api.getModel();
+        model.onSortChanged(evt);
+      } else {
+        this.getDataFromServer();
+      }
+    }
+  }, {
+    key: "pagination",
+    value: function pagination(page, pageSize) {
+      var _this7 = this;
+
+      this.setState({
+        page: page,
+        pageSize: pageSize
+      }, function () {
+        if (_this7.isClientMode()) {
+          withSyncRender(function () {
+            _this7.api.paginationGoToPage(page - 1);
+
+            _this7.api.paginationSetPageSize(pageSize);
+          });
+        } else {
+          _this7.getDataFromServer();
+        }
+      });
+    }
+  }, {
+    key: "LoadingOverlay",
+    value: function LoadingOverlay() {
+      return /*#__PURE__*/React.createElement(Spin, null);
+    }
+  }, {
+    key: "NoRowsOverlay",
+    value: function NoRowsOverlay() {
+      return /*#__PURE__*/React.createElement("div", {
+        className: prefix('empty')
+      }, /*#__PURE__*/React.createElement("img", {
+        src: empty
+      }), /*#__PURE__*/React.createElement("div", null, "\u6682\u65E0\u6570\u636E"));
+    }
+  }, {
+    key: "getMainMenuItems",
+    value: function getMainMenuItems(params) {
+      if (params.defaultItems.includes('pinSubMenu')) {
+        return params.defaultItems;
+      }
+
+      return ['pinSubMenu', 'separator'].concat(_toConsumableArray(params.defaultItems));
+    }
+  }, {
+    key: "validateRecord",
+    value: function validateRecord(record) {
+      var _this8 = this;
+
+      if (this.validator === null) {
+        return;
+      }
+
+      var rowId = this.getRowId({
+        data: record
+      });
+      return this.validator.validate(record).then(function () {
+        var errors = new Map(_this8.store.getState().errors);
+        var error = errors.get(rowId);
+
+        if (error === undefined) {
+          return;
+        }
+
+        errors.delete(rowId);
+
+        _this8.store.setState({
+          errors: errors
+        });
+      }).catch(function (_ref4) {
+        var fields = _ref4.fields;
+        var errors = new Map(_this8.store.getState().errors);
+        var error = new Map();
+        Object.entries(fields).forEach(function (item) {
+          error.set(item[0], item[1].map(function (err) {
+            return err.message || "".concat(item[0], "\u8F93\u5165\u9519\u8BEF");
+          }));
+        });
+        errors.set(rowId, error);
+
+        _this8.store.setState({
+          errors: errors
+        });
+      });
+    }
+  }, {
+    key: "validate",
+    value: function () {
+      var _validate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var _this9 = this;
+
+        var result, flag, errors, failed;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return Promise.allSettled(this.dataSource.map(function (record) {
+                  var rowId = _this9.getRowId({
+                    data: record
+                  });
+
+                  if (_this9.validator === null) {
+                    return Promise.resolve(true);
+                  }
+
+                  return _this9.validator.validate(record).catch(function (_ref5) {
+                    var fields = _ref5.fields;
+                    return Promise.reject({
+                      id: rowId,
+                      fields: fields
+                    });
+                  });
+                }));
+
+              case 2:
+                result = _context.sent;
+                flag = false;
+                errors = new Map();
+                failed = [];
+                result.forEach(function (item) {
+                  if (item.status === 'rejected') {
+                    var _ref6 = item.reason,
+                        id = _ref6.id,
+                        fields = _ref6.fields;
+                    var error = new Map();
+                    Object.entries(fields).forEach(function (item) {
+                      error.set(item[0], item[1].map(function (err) {
+                        return err.message || "".concat(item[0], "\u8F93\u5165\u9519\u8BEF");
+                      }));
+                    });
+                    errors.set(id, error);
+                    failed.push(item.reason);
+                    flag = true;
+                  }
+                });
+
+                if (!flag) {
+                  _context.next = 10;
+                  break;
+                }
+
+                this.store.setState({
+                  errors: errors
+                });
+                return _context.abrupt("return", Promise.reject(failed));
+
+              case 10:
+                return _context.abrupt("return", true);
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function validate() {
+        return _validate.apply(this, arguments);
+      }
+
+      return validate;
+    }()
+  }, {
+    key: "fetch",
+    value: function fetch(page) {
+      var _this10 = this;
+
+      var curr = page || 1;
+
+      var delay = function delay() {
+        if (_this10.isReady) {
+          _this10.getDataFromServer();
+        } else {
+          requestAnimationFrame(delay);
+        }
+      };
+
+      this.setState({
+        page: curr
+      }, delay);
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      this.getDataFromServer();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this11 = this;
+
+      var _this$props6 = this.props,
+          rowSelection = _this$props6.rowSelection,
+          rowKey = _this$props6.rowKey,
+          fetch = _this$props6.fetch,
+          dataSource = _this$props6.dataSource,
+          summary = _this$props6.summary,
+          rowActions = _this$props6.rowActions,
+          context = _this$props6.context,
+          onGridReady = _this$props6.onGridReady,
+          pagination = _this$props6.pagination,
+          defaultColDefProp = _this$props6.defaultColDef,
+          restProps = _objectWithoutProperties(_this$props6, _excluded4);
+
+      var _this$state2 = this.state,
+          colDefs = _this$state2.colDefs,
+          enablePagination = _this$state2.pagination,
+          page = _this$state2.page,
+          pageSize = _this$state2.pageSize,
+          total = _this$state2.total;
+      var mPage = _typeof(pagination) === 'object' ? pagination : {};
+      return /*#__PURE__*/React.createElement(GridContext.Provider, {
+        value: this.store
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "ag-theme-lemon ".concat(prefix()),
+        style: restProps.domLayout === 'autoHeight' ? {
+          height: 'auto'
+        } : undefined
+      }, /*#__PURE__*/React.createElement(AgGridReact, _extends({
+        singleClickEdit: true,
+        suppressPaginationPanel: true,
+        onCellValueChanged: this.cellValueChanged,
+        onCellEditingStopped: this.cellEditingStop,
+        loadingOverlayComponent: this.LoadingOverlay,
+        noRowsOverlayComponent: this.NoRowsOverlay,
+        getMainMenuItems: this.getMainMenuItems,
+        rowData: this.emptyRowData,
+        components: {
+          headerComponent: HeaderRenderer
+        }
+      }, restProps, {
+        pagination: enablePagination,
+        paginationPageSize: pageSize,
+        columnDefs: colDefs,
+        getRowId: this.getRowId,
+        onGridReady: this.init,
+        context: context,
+        rowSelection: rowSelection !== undefined ? rowSelection.type !== 'radio' ? 'multiple' : 'single' : undefined,
+        defaultColDef: _objectSpread(_objectSpread({}, defaultColDef), defaultColDefProp),
+        pinnedBottomRowData: Array.isArray(summary) ? summary : summary ? [summary] : undefined
+      })), /*#__PURE__*/React.createElement("div", {
+        className: prefix('bottom')
+      }, /*#__PURE__*/React.createElement("div", null), enablePagination && /*#__PURE__*/React.createElement(Pagination, _extends({
+        size: "small",
+        showPrevNextJumpers: true,
+        showSizeChanger: true,
+        showQuickJumper: true,
+        showTotal: function showTotal(val) {
+          return "\u5171".concat(val, "\u6761");
+        },
+        defaultCurrent: 1,
+        defaultPageSize: 20,
+        pageSizeOptions: ['10', '20', '50', '100']
+      }, mPage, {
+        pageSize: pageSize,
+        current: page,
+        total: total,
+        onChange: function onChange(page, pageSize) {
+          _this11.pagination(page, pageSize);
+
+          if (mPage.onChange) {
+            mPage.onChange(page, pageSize);
+          }
+        }
+      })))));
+    }
+  }]);
+
+  return DataGrid;
+}(Component);
+
+_defineProperty(DataGrid, "defaultProps", {
+  autoLoad: false,
+  columnTypes: columnTypes,
+  localeText: {
+    copy: '复制',
+    copyWithHeaders: '复制(带表头)',
+    copyWithGroupHeaders: '复制(带表头分组)',
+    paste: '粘贴',
+    export: '导出',
+    csvExport: 'CSV 导出',
+    searchOoo: '搜索',
+    autosizeThiscolumn: '当前列宽自适应',
+    autosizeAllColumns: '所有列宽自适应',
+    resetColumns: '重置所有列',
+    pinColumn: '固定列',
+    pinLeft: '固定在左侧',
+    pinRight: '固定在右侧',
+    noPin: '不固定',
+    expandAll: '展开所有',
+    collapseAll: '折叠所有'
+  }
+});
+
+_defineProperty(DataGrid, "EmptyCol", {
+  field: '__empty_column__',
+  flex: 1,
+  resizable: false,
+  suppressMovable: true,
+  headerName: '',
+  suppressNavigable: true,
+  lockVisible: true,
+  suppressMenu: true
+});
+
+_defineProperty(DataGrid, "Editors", {
+  Text: TextEditor,
+  Date: DateEditor,
+  Number: NumberEditor,
+  Select: SelectEditor,
+  Wrapper: EditorWrapper
+});
+
+export { DataGrid as default };