webpackJsonp([109],{ /***/ 1022: /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports["default"] = void 0; var React = _interopRequireWildcard(__webpack_require__(0)); var _classnames = _interopRequireDefault(__webpack_require__(3)); var _button = _interopRequireDefault(__webpack_require__(73)); var _configProvider = __webpack_require__(9); var _dropdown = _interopRequireDefault(__webpack_require__(868)); var _icon = _interopRequireDefault(__webpack_require__(26)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } function _extends() { _extends = Object.assign || 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 _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); return Constructor; } function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 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 } }); if (superClass) _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var __rest = void 0 && (void 0).__rest || function (s, e) { var t = {}; for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; } if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t; }; var ButtonGroup = _button["default"].Group; var DropdownButton = /*#__PURE__*/ function (_React$Component) { _inherits(DropdownButton, _React$Component); function DropdownButton() { var _this; _classCallCheck(this, DropdownButton); _this = _possibleConstructorReturn(this, _getPrototypeOf(DropdownButton).apply(this, arguments)); _this.renderButton = function (_ref) { var getContextPopupContainer = _ref.getPopupContainer, getPrefixCls = _ref.getPrefixCls; var _a = _this.props, customizePrefixCls = _a.prefixCls, type = _a.type, disabled = _a.disabled, onClick = _a.onClick, htmlType = _a.htmlType, children = _a.children, className = _a.className, overlay = _a.overlay, trigger = _a.trigger, align = _a.align, visible = _a.visible, onVisibleChange = _a.onVisibleChange, placement = _a.placement, getPopupContainer = _a.getPopupContainer, href = _a.href, _a$icon = _a.icon, icon = _a$icon === void 0 ? React.createElement(_icon["default"], { type: "ellipsis" }) : _a$icon, title = _a.title, restProps = __rest(_a, ["prefixCls", "type", "disabled", "onClick", "htmlType", "children", "className", "overlay", "trigger", "align", "visible", "onVisibleChange", "placement", "getPopupContainer", "href", "icon", "title"]); var prefixCls = getPrefixCls('dropdown-button', customizePrefixCls); var dropdownProps = { align: align, overlay: overlay, disabled: disabled, trigger: disabled ? [] : trigger, onVisibleChange: onVisibleChange, placement: placement, getPopupContainer: getPopupContainer || getContextPopupContainer }; if ('visible' in _this.props) { dropdownProps.visible = visible; } return React.createElement(ButtonGroup, _extends({}, restProps, { className: (0, _classnames["default"])(prefixCls, className) }), React.createElement(_button["default"], { type: type, disabled: disabled, onClick: onClick, htmlType: htmlType, href: href, title: title }, children), React.createElement(_dropdown["default"], dropdownProps, React.createElement(_button["default"], { type: type }, icon))); }; return _this; } _createClass(DropdownButton, [{ key: "render", value: function render() { return React.createElement(_configProvider.ConfigConsumer, null, this.renderButton); } }]); return DropdownButton; }(React.Component); exports["default"] = DropdownButton; DropdownButton.defaultProps = { placement: 'bottomRight', type: 'default' }; //# sourceMappingURL=dropdown-button.js.map /***/ }), /***/ 1026: /***/ (function(module, exports, __webpack_require__) { var overArg = __webpack_require__(921); /** Built-in value references. */ var getPrototype = overArg(Object.getPrototypeOf, Object); module.exports = getPrototype; /***/ }), /***/ 1027: /***/ (function(module, exports, __webpack_require__) { var arrayLikeKeys = __webpack_require__(922), baseKeysIn = __webpack_require__(1160), isArrayLike = __webpack_require__(844); /** * Creates an array of the own and inherited enumerable property names of `object`. * * **Note:** Non-object values are coerced to objects. * * @static * @memberOf _ * @since 3.0.0 * @category Object * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. * @example * * function Foo() { * this.a = 1; * this.b = 2; * } * * Foo.prototype.c = 3; * * _.keysIn(new Foo); * // => ['a', 'b', 'c'] (iteration order is not guaranteed) */ function keysIn(object) { return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); } module.exports = keysIn; /***/ }), /***/ 1050: /***/ (function(module, exports, __webpack_require__) { var baseAssignValue = __webpack_require__(839), eq = __webpack_require__(820); /** * This function is like `assignValue` except that it doesn't assign * `undefined` values. * * @private * @param {Object} object The object to modify. * @param {string} key The key of the property to assign. * @param {*} value The value to assign. */ function assignMergeValue(object, key, value) { if ((value !== undefined && !eq(object[key], value)) || (value === undefined && !(key in object))) { baseAssignValue(object, key, value); } } module.exports = assignMergeValue; /***/ }), /***/ 1051: /***/ (function(module, exports) { /** * Gets the value at `key`, unless `key` is "__proto__" or "constructor". * * @private * @param {Object} object The object to query. * @param {string} key The key of the property to get. * @returns {*} Returns the property value. */ function safeGet(object, key) { if (key === 'constructor' && typeof object[key] === 'function') { return; } if (key == '__proto__') { return; } return object[key]; } module.exports = safeGet; /***/ }), /***/ 1067: /***/ (function(module, exports, __webpack_require__) { "use strict"; function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 _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); return Constructor; } function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 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 } }); if (superClass) _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var __importStar = this && this.__importStar || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) { if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; } result["default"] = mod; return result; }; var __importDefault = this && this.__importDefault || function (mod) { return mod && mod.__esModule ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); var React = __importStar(__webpack_require__(0)); var PropTypes = __importStar(__webpack_require__(1)); var mini_store_1 = __webpack_require__(87); var classnames_1 = __importDefault(__webpack_require__(3)); var ColGroup_1 = __importDefault(__webpack_require__(1235)); var TableHeader_1 = __importDefault(__webpack_require__(1236)); var TableRow_1 = __importDefault(__webpack_require__(1068)); var ExpandableRow_1 = __importDefault(__webpack_require__(1239)); var BaseTable = /*#__PURE__*/ function (_React$Component) { _inherits(BaseTable, _React$Component); function BaseTable() { var _this; _classCallCheck(this, BaseTable); _this = _possibleConstructorReturn(this, _getPrototypeOf(BaseTable).apply(this, arguments)); _this.handleRowHover = function (isHover, key) { _this.props.store.setState({ currentHoverKey: isHover ? key : null }); }; _this.renderRows = function (renderData, indent) { var ancestorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; var table = _this.context.table; var columnManager = table.columnManager, components = table.components; var _table$props = table.props, prefixCls = _table$props.prefixCls, childrenColumnName = _table$props.childrenColumnName, rowClassName = _table$props.rowClassName, rowRef = _table$props.rowRef, onRowClick = _table$props.onRowClick, onRowDoubleClick = _table$props.onRowDoubleClick, onRowContextMenu = _table$props.onRowContextMenu, onRowMouseEnter = _table$props.onRowMouseEnter, onRowMouseLeave = _table$props.onRowMouseLeave, onRow = _table$props.onRow; var _this$props = _this.props, getRowKey = _this$props.getRowKey, fixed = _this$props.fixed, expander = _this$props.expander, isAnyColumnsFixed = _this$props.isAnyColumnsFixed; var rows = []; var _loop = function _loop(i) { var record = renderData[i]; var key = getRowKey(record, i); var className = typeof rowClassName === 'string' ? rowClassName : rowClassName(record, i, indent); var onHoverProps = {}; if (columnManager.isAnyColumnsFixed()) { onHoverProps.onHover = _this.handleRowHover; } var leafColumns = void 0; if (fixed === 'left') { leafColumns = columnManager.leftLeafColumns(); } else if (fixed === 'right') { leafColumns = columnManager.rightLeafColumns(); } else { leafColumns = _this.getColumns(columnManager.leafColumns()); } var rowPrefixCls = "".concat(prefixCls, "-row"); var row = React.createElement(ExpandableRow_1.default, Object.assign({}, expander.props, { fixed: fixed, index: i, prefixCls: rowPrefixCls, record: record, key: key, rowKey: key, onRowClick: onRowClick, needIndentSpaced: expander.needIndentSpaced, onExpandedChange: expander.handleExpandChange }), function (expandableRow) { return React.createElement(TableRow_1.default, Object.assign({ fixed: fixed, indent: indent, className: className, record: record, index: i, prefixCls: rowPrefixCls, childrenColumnName: childrenColumnName, columns: leafColumns, onRow: onRow, onRowDoubleClick: onRowDoubleClick, onRowContextMenu: onRowContextMenu, onRowMouseEnter: onRowMouseEnter, onRowMouseLeave: onRowMouseLeave }, onHoverProps, { rowKey: key, ancestorKeys: ancestorKeys, ref: rowRef(record, i, indent), components: components, isAnyColumnsFixed: isAnyColumnsFixed }, expandableRow)); }); rows.push(row); expander.renderRows(_this.renderRows, rows, record, i, indent, fixed, key, ancestorKeys); }; for (var i = 0; i < renderData.length; i += 1) { _loop(i); } return rows; }; return _this; } _createClass(BaseTable, [{ key: "getColumns", value: function getColumns(cols) { var _this$props2 = this.props, _this$props2$columns = _this$props2.columns, columns = _this$props2$columns === void 0 ? [] : _this$props2$columns, fixed = _this$props2.fixed; var table = this.context.table; var prefixCls = table.props.prefixCls; return (cols || columns).map(function (column) { return _objectSpread({}, column, { className: !!column.fixed && !fixed ? classnames_1.default("".concat(prefixCls, "-fixed-columns-in-body"), column.className) : column.className }); }); } }, { key: "render", value: function render() { var table = this.context.table; var components = table.components; var _table$props2 = table.props, prefixCls = _table$props2.prefixCls, scroll = _table$props2.scroll, data = _table$props2.data, getBodyWrapper = _table$props2.getBodyWrapper; var _this$props3 = this.props, expander = _this$props3.expander, tableClassName = _this$props3.tableClassName, hasHead = _this$props3.hasHead, hasBody = _this$props3.hasBody, fixed = _this$props3.fixed; var tableStyle = {}; if (!fixed && scroll.x) { // not set width, then use content fixed width tableStyle.width = scroll.x === true ? 'max-content' : scroll.x; } var Table = hasBody ? components.table : 'table'; var BodyWrapper = components.body.wrapper; var body; if (hasBody) { body = React.createElement(BodyWrapper, { className: "".concat(prefixCls, "-tbody") }, this.renderRows(data, 0)); if (getBodyWrapper) { body = getBodyWrapper(body); } } var columns = this.getColumns(); return React.createElement(Table, { className: tableClassName, style: tableStyle, key: "table" }, React.createElement(ColGroup_1.default, { columns: columns, fixed: fixed }), hasHead && React.createElement(TableHeader_1.default, { expander: expander, columns: columns, fixed: fixed }), body); } }]); return BaseTable; }(React.Component); BaseTable.contextTypes = { table: PropTypes.any }; exports.default = mini_store_1.connect()(BaseTable); /***/ }), /***/ 1068: /***/ (function(module, exports, __webpack_require__) { "use strict"; function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(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; } function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 _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); return Constructor; } function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 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 } }); if (superClass) _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var __importStar = this && this.__importStar || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) { if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; } result["default"] = mod; return result; }; var __importDefault = this && this.__importDefault || function (mod) { return mod && mod.__esModule ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); var React = __importStar(__webpack_require__(0)); var react_dom_1 = __importDefault(__webpack_require__(4)); var warning_1 = __importDefault(__webpack_require__(177)); var mini_store_1 = __webpack_require__(87); var react_lifecycles_compat_1 = __webpack_require__(7); var classnames_1 = __importDefault(__webpack_require__(3)); var TableCell_1 = __importDefault(__webpack_require__(1238)); var TableRow = /*#__PURE__*/ function (_React$Component) { _inherits(TableRow, _React$Component); function TableRow() { var _this; _classCallCheck(this, TableRow); _this = _possibleConstructorReturn(this, _getPrototypeOf(TableRow).apply(this, arguments)); _this.state = {}; _this.onTriggerEvent = function (rowPropFunc, legacyFunc, additionalFunc) { var _this$props = _this.props, record = _this$props.record, index = _this$props.index; return function () { // Additional function like trigger `this.onHover` to handle self logic if (additionalFunc) { additionalFunc(); } // [Legacy] Some legacy function like `onRowClick`. for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } var event = args[0]; if (legacyFunc) { legacyFunc(record, index, event); } // Pass to the function from `onRow` if (rowPropFunc) { rowPropFunc.apply(void 0, args); } }; }; _this.onMouseEnter = function () { var _this$props2 = _this.props, onHover = _this$props2.onHover, rowKey = _this$props2.rowKey; onHover(true, rowKey); }; _this.onMouseLeave = function () { var _this$props3 = _this.props, onHover = _this$props3.onHover, rowKey = _this$props3.rowKey; onHover(false, rowKey); }; return _this; } _createClass(TableRow, [{ key: "componentDidMount", value: function componentDidMount() { if (this.state.shouldRender) { this.saveRowRef(); } } }, { key: "shouldComponentUpdate", value: function shouldComponentUpdate(nextProps) { return !!(this.props.visible || nextProps.visible); } }, { key: "componentDidUpdate", value: function componentDidUpdate() { if (this.state.shouldRender && !this.rowRef) { this.saveRowRef(); } } }, { key: "setExpandedRowHeight", value: function setExpandedRowHeight() { var _this$props4 = this.props, store = _this$props4.store, rowKey = _this$props4.rowKey; var _store$getState = store.getState(), expandedRowsHeight = _store$getState.expandedRowsHeight; var _this$rowRef$getBound = this.rowRef.getBoundingClientRect(), height = _this$rowRef$getBound.height; expandedRowsHeight = _objectSpread({}, expandedRowsHeight, _defineProperty({}, rowKey, height)); store.setState({ expandedRowsHeight: expandedRowsHeight }); } }, { key: "setRowHeight", value: function setRowHeight() { var _this$props5 = this.props, store = _this$props5.store, rowKey = _this$props5.rowKey; var _store$getState2 = store.getState(), fixedColumnsBodyRowsHeight = _store$getState2.fixedColumnsBodyRowsHeight; var _this$rowRef$getBound2 = this.rowRef.getBoundingClientRect(), height = _this$rowRef$getBound2.height; store.setState({ fixedColumnsBodyRowsHeight: _objectSpread({}, fixedColumnsBodyRowsHeight, _defineProperty({}, rowKey, height)) }); } }, { key: "getStyle", value: function getStyle() { var _this$props6 = this.props, height = _this$props6.height, visible = _this$props6.visible; if (height && height !== this.style.height) { this.style = _objectSpread({}, this.style, { height: height }); } if (!visible && !this.style.display) { this.style = _objectSpread({}, this.style, { display: 'none' }); } return this.style; } }, { key: "saveRowRef", value: function saveRowRef() { this.rowRef = react_dom_1.default.findDOMNode(this); var _this$props7 = this.props, isAnyColumnsFixed = _this$props7.isAnyColumnsFixed, fixed = _this$props7.fixed, expandedRow = _this$props7.expandedRow, ancestorKeys = _this$props7.ancestorKeys; if (!isAnyColumnsFixed || !this.rowRef) { return; } if (!fixed && expandedRow) { this.setExpandedRowHeight(); } if (!fixed && ancestorKeys.length >= 0) { this.setRowHeight(); } } }, { key: "render", value: function render() { if (!this.state.shouldRender) { return null; } var _this$props8 = this.props, prefixCls = _this$props8.prefixCls, columns = _this$props8.columns, record = _this$props8.record, rowKey = _this$props8.rowKey, index = _this$props8.index, onRow = _this$props8.onRow, indent = _this$props8.indent, indentSize = _this$props8.indentSize, hovered = _this$props8.hovered, height = _this$props8.height, visible = _this$props8.visible, components = _this$props8.components, hasExpandIcon = _this$props8.hasExpandIcon, renderExpandIcon = _this$props8.renderExpandIcon, renderExpandIconCell = _this$props8.renderExpandIconCell, onRowClick = _this$props8.onRowClick, onRowDoubleClick = _this$props8.onRowDoubleClick, onRowMouseEnter = _this$props8.onRowMouseEnter, onRowMouseLeave = _this$props8.onRowMouseLeave, onRowContextMenu = _this$props8.onRowContextMenu; var BodyRow = components.body.row; var BodyCell = components.body.cell; var className = this.props.className; if (hovered) { className += " ".concat(prefixCls, "-hover"); } var cells = []; renderExpandIconCell(cells); for (var i = 0; i < columns.length; i += 1) { var column = columns[i]; warning_1.default(column.onCellClick === undefined, 'column[onCellClick] is deprecated, please use column[onCell] instead.'); cells.push(React.createElement(TableCell_1.default, { prefixCls: prefixCls, record: record, indentSize: indentSize, indent: indent, index: index, column: column, key: column.key || column.dataIndex, expandIcon: hasExpandIcon(i) && renderExpandIcon(), component: BodyCell })); } var _ref = onRow(record, index) || {}, customClassName = _ref.className, customStyle = _ref.style, rowProps = _objectWithoutProperties(_ref, ["className", "style"]); var style = { height: height }; if (!visible) { style.display = 'none'; } style = _objectSpread({}, style, {}, customStyle); var rowClassName = classnames_1.default(prefixCls, className, "".concat(prefixCls, "-level-").concat(indent), customClassName); return React.createElement(BodyRow, Object.assign({}, rowProps, { onClick: this.onTriggerEvent(rowProps.onClick, onRowClick), onDoubleClick: this.onTriggerEvent(rowProps.onDoubleClick, onRowDoubleClick), onMouseEnter: this.onTriggerEvent(rowProps.onMouseEnter, onRowMouseEnter, this.onMouseEnter), onMouseLeave: this.onTriggerEvent(rowProps.onMouseLeave, onRowMouseLeave, this.onMouseLeave), onContextMenu: this.onTriggerEvent(rowProps.onContextMenu, onRowContextMenu), className: rowClassName, style: style, "data-row-key": rowKey }), cells); } }], [{ key: "getDerivedStateFromProps", value: function getDerivedStateFromProps(nextProps, prevState) { if (prevState.visible || !prevState.visible && nextProps.visible) { return { shouldRender: true, visible: nextProps.visible }; } return { visible: nextProps.visible }; } }]); return TableRow; }(React.Component); TableRow.defaultProps = { onRow: function onRow() {}, onHover: function onHover() {}, hasExpandIcon: function hasExpandIcon() {}, renderExpandIcon: function renderExpandIcon() {}, renderExpandIconCell: function renderExpandIconCell() {} }; function getRowHeight(state, props) { var expandedRowsHeight = state.expandedRowsHeight, fixedColumnsBodyRowsHeight = state.fixedColumnsBodyRowsHeight; var fixed = props.fixed, rowKey = props.rowKey; if (!fixed) { return null; } if (expandedRowsHeight[rowKey]) { return expandedRowsHeight[rowKey]; } if (fixedColumnsBodyRowsHeight[rowKey]) { return fixedColumnsBodyRowsHeight[rowKey]; } return null; } react_lifecycles_compat_1.polyfill(TableRow); exports.default = mini_store_1.connect(function (state, props) { var currentHoverKey = state.currentHoverKey, expandedRowKeys = state.expandedRowKeys; var rowKey = props.rowKey, ancestorKeys = props.ancestorKeys; var visible = ancestorKeys.length === 0 || ancestorKeys.every(function (k) { return expandedRowKeys.includes(k); }); return { visible: visible, hovered: currentHoverKey === rowKey, height: getRowHeight(state, props) }; })(TableRow); /***/ }), /***/ 1069: /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var Column = function Column() { return null; }; exports.default = Column; /***/ }), /***/ 1070: /***/ (function(module, exports, __webpack_require__) { "use strict"; function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 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 } }); if (superClass) _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var __importStar = this && this.__importStar || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) { if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; } result["default"] = mod; return result; }; Object.defineProperty(exports, "__esModule", { value: true }); var React = __importStar(__webpack_require__(0)); var ColumnGroup = /*#__PURE__*/ function (_React$Component) { _inherits(ColumnGroup, _React$Component); function ColumnGroup() { _classCallCheck(this, ColumnGroup); return _possibleConstructorReturn(this, _getPrototypeOf(ColumnGroup).apply(this, arguments)); } return ColumnGroup; }(React.Component); exports.default = ColumnGroup; ColumnGroup.isTableColumnGroup = true; /***/ }), /***/ 1071: /***/ (function(module, exports, __webpack_require__) { "use strict"; function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } Object.defineProperty(exports, "__esModule", { value: true }); exports.flatArray = flatArray; exports.treeMap = treeMap; exports.flatFilter = flatFilter; exports.normalizeColumns = normalizeColumns; exports.generateValueMaps = generateValueMaps; var React = _interopRequireWildcard(__webpack_require__(0)); function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } function _extends() { _extends = Object.assign || 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 flatArray() { var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; var childrenName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'children'; var result = []; var loop = function loop(array) { array.forEach(function (item) { if (item[childrenName]) { var newItem = _extends({}, item); delete newItem[childrenName]; result.push(newItem); if (item[childrenName].length > 0) { loop(item[childrenName]); } } else { result.push(item); } }); }; loop(data); return result; } function treeMap(tree, mapper) { var childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children'; return tree.map(function (node, index) { var extra = {}; if (node[childrenName]) { extra[childrenName] = treeMap(node[childrenName], mapper, childrenName); } return _extends(_extends({}, mapper(node, index)), extra); }); } function flatFilter(tree, callback) { return tree.reduce(function (acc, node) { if (callback(node)) { acc.push(node); } if (node.children) { var children = flatFilter(node.children, callback); acc.push.apply(acc, _toConsumableArray(children)); } return acc; }, []); } function normalizeColumns(elements) { var columns = []; React.Children.forEach(elements, function (element) { if (!React.isValidElement(element)) { return; } var column = _extends({}, element.props); if (element.key) { column.key = element.key; } if (element.type && element.type.__ANT_TABLE_COLUMN_GROUP) { column.children = normalizeColumns(column.children); } columns.push(column); }); return columns; } function generateValueMaps(items) { var maps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; (items || []).forEach(function (_ref) { var value = _ref.value, children = _ref.children; maps[value.toString()] = value; generateValueMaps(children, maps); }); return maps; } //# sourceMappingURL=util.js.map /***/ }), /***/ 1124: /***/ (function(module, exports, __webpack_require__) { var assignValue = __webpack_require__(866), baseAssignValue = __webpack_require__(839); /** * Copies properties of `source` to `object`. * * @private * @param {Object} source The object to copy properties from. * @param {Array} props The property identifiers to copy. * @param {Object} [object={}] The object to copy properties to. * @param {Function} [customizer] The function to customize copied values. * @returns {Object} Returns `object`. */ function copyObject(source, props, object, customizer) { var isNew = !object; object || (object = {}); var index = -1, length = props.length; while (++index < length) { var key = props[index]; var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined; if (newValue === undefined) { newValue = source[key]; } if (isNew) { baseAssignValue(object, key, newValue); } else { assignValue(object, key, newValue); } } return object; } module.exports = copyObject; /***/ }), /***/ 1126: /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var _defineProperty2 = __webpack_require__(66); var _defineProperty3 = _interopRequireDefault(_defineProperty2); exports.toArray = toArray; exports.getActiveIndex = getActiveIndex; exports.getActiveKey = getActiveKey; exports.setTransform = setTransform; exports.isTransform3dSupported = isTransform3dSupported; exports.setTransition = setTransition; exports.getTransformPropValue = getTransformPropValue; exports.isVertical = isVertical; exports.getTransformByIndex = getTransformByIndex; exports.getMarginStyle = getMarginStyle; exports.getStyle = getStyle; exports.setPxStyle = setPxStyle; exports.getDataAttr = getDataAttr; exports.getLeft = getLeft; exports.getTop = getTop; var _react = __webpack_require__(0); var _react2 = _interopRequireDefault(_react); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } function toArray(children) { // allow [c,[a,b]] var c = []; _react2['default'].Children.forEach(children, function (child) { if (child) { c.push(child); } }); return c; } function getActiveIndex(children, activeKey) { var c = toArray(children); for (var i = 0; i < c.length; i++) { if (c[i].key === activeKey) { return i; } } return -1; } function getActiveKey(children, index) { var c = toArray(children); return c[index].key; } function setTransform(style, v) { style.transform = v; style.webkitTransform = v; style.mozTransform = v; } function isTransform3dSupported(style) { return ('transform' in style || 'webkitTransform' in style || 'MozTransform' in style) && window.atob; } function setTransition(style, v) { style.transition = v; style.webkitTransition = v; style.MozTransition = v; } function getTransformPropValue(v) { return { transform: v, WebkitTransform: v, MozTransform: v }; } function isVertical(tabBarPosition) { return tabBarPosition === 'left' || tabBarPosition === 'right'; } function getTransformByIndex(index, tabBarPosition) { var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'ltr'; var translate = isVertical(tabBarPosition) ? 'translateY' : 'translateX'; if (!isVertical(tabBarPosition) && direction === 'rtl') { return translate + '(' + index * 100 + '%) translateZ(0)'; } return translate + '(' + -index * 100 + '%) translateZ(0)'; } function getMarginStyle(index, tabBarPosition) { var marginDirection = isVertical(tabBarPosition) ? 'marginTop' : 'marginLeft'; return (0, _defineProperty3['default'])({}, marginDirection, -index * 100 + '%'); } function getStyle(el, property) { return +window.getComputedStyle(el).getPropertyValue(property).replace('px', ''); } function setPxStyle(el, value, vertical) { value = vertical ? '0px, ' + value + 'px, 0px' : value + 'px, 0px, 0px'; setTransform(el.style, 'translate3d(' + value + ')'); } function getDataAttr(props) { return Object.keys(props).reduce(function (prev, key) { if (key.substr(0, 5) === 'aria-' || key.substr(0, 5) === 'data-' || key === 'role') { prev[key] = props[key]; } return prev; }, {}); } function toNum(style, property) { return +style.getPropertyValue(property).replace('px', ''); } function getTypeValue(start, current, end, tabNode, wrapperNode) { var total = getStyle(wrapperNode, 'padding-' + start); if (!tabNode || !tabNode.parentNode) { return total; } var childNodes = tabNode.parentNode.childNodes; Array.prototype.some.call(childNodes, function (node) { var style = window.getComputedStyle(node); if (node !== tabNode) { total += toNum(style, 'margin-' + start); total += node[current]; total += toNum(style, 'margin-' + end); if (style.boxSizing === 'content-box') { total += toNum(style, 'border-' + start + '-width') + toNum(style, 'border-' + end + '-width'); } return false; } // We need count current node margin // ref: https://github.com/react-component/tabs/pull/139#issuecomment-431005262 total += toNum(style, 'margin-' + start); return true; }); return total; } function getLeft(tabNode, wrapperNode) { return getTypeValue('left', 'offsetWidth', 'right', tabNode, wrapperNode); } function getTop(tabNode, wrapperNode) { return getTypeValue('top', 'offsetHeight', 'bottom', tabNode, wrapperNode); } /***/ }), /***/ 1130: /***/ (function(module, exports, __webpack_require__) { var baseMerge = __webpack_require__(1212), createAssigner = __webpack_require__(1216); /** * This method is like `_.assign` except that it recursively merges own and * inherited enumerable string keyed properties of source objects into the * destination object. Source properties that resolve to `undefined` are * skipped if a destination value exists. Array and plain object properties * are merged recursively. Other objects and value types are overridden by * assignment. Source objects are applied from left to right. Subsequent * sources overwrite property assignments of previous sources. * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 0.5.0 * @category Object * @param {Object} object The destination object. * @param {...Object} [sources] The source objects. * @returns {Object} Returns `object`. * @example * * var object = { * 'a': [{ 'b': 2 }, { 'd': 4 }] * }; * * var other = { * 'a': [{ 'c': 3 }, { 'e': 5 }] * }; * * _.merge(object, other); * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } */ var merge = createAssigner(function(object, source, srcIndex) { baseMerge(object, source, srcIndex); }); module.exports = merge; /***/ }), /***/ 1131: /***/ (function(module, exports, __webpack_require__) { var Uint8Array = __webpack_require__(920); /** * Creates a clone of `arrayBuffer`. * * @private * @param {ArrayBuffer} arrayBuffer The array buffer to clone. * @returns {ArrayBuffer} Returns the cloned array buffer. */ function cloneArrayBuffer(arrayBuffer) { var result = new arrayBuffer.constructor(arrayBuffer.byteLength); new Uint8Array(result).set(new Uint8Array(arrayBuffer)); return result; } module.exports = cloneArrayBuffer; /***/ }), /***/ 1135: /***/ (function(module, exports, __webpack_require__) { "use strict"; __webpack_require__(27); __webpack_require__(1227); __webpack_require__(180); __webpack_require__(171); __webpack_require__(297); __webpack_require__(932); __webpack_require__(71); __webpack_require__(850); //# sourceMappingURL=css.js.map /***/ }), /***/ 1136: /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports["default"] = void 0; var _Table = _interopRequireDefault(__webpack_require__(1230)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } var _default = _Table["default"]; exports["default"] = _default; //# sourceMappingURL=index.js.map /***/ }), /***/ 1145: /***/ (function(module, exports, __webpack_require__) { var createBaseFor = __webpack_require__(1158); /** * The base implementation of `baseForOwn` which iterates over `object` * properties returned by `keysFunc` and invokes `iteratee` for each property. * Iteratee functions may exit iteration early by explicitly returning `false`. * * @private * @param {Object} object The object to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {Function} keysFunc The function to get the keys of `object`. * @returns {Object} Returns `object`. */ var baseFor = createBaseFor(); module.exports = baseFor; /***/ }), /***/ 1146: /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(162); /** Detect free variable `exports`. */ var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; /** Detect free variable `module`. */ var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; /** Detect the popular CommonJS extension `module.exports`. */ var moduleExports = freeModule && freeModule.exports === freeExports; /** Built-in value references. */ var Buffer = moduleExports ? root.Buffer : undefined, allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined; /** * Creates a clone of `buffer`. * * @private * @param {Buffer} buffer The buffer to clone. * @param {boolean} [isDeep] Specify a deep clone. * @returns {Buffer} Returns the cloned buffer. */ function cloneBuffer(buffer, isDeep) { if (isDeep) { return buffer.slice(); } var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); buffer.copy(result); return result; } module.exports = cloneBuffer; /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(300)(module))) /***/ }), /***/ 1147: /***/ (function(module, exports, __webpack_require__) { var cloneArrayBuffer = __webpack_require__(1131); /** * Creates a clone of `typedArray`. * * @private * @param {Object} typedArray The typed array to clone. * @param {boolean} [isDeep] Specify a deep clone. * @returns {Object} Returns the cloned typed array. */ function cloneTypedArray(typedArray, isDeep) { var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); } module.exports = cloneTypedArray; /***/ }), /***/ 1148: /***/ (function(module, exports) { /** * Copies the values of `source` to `array`. * * @private * @param {Array} source The array to copy values from. * @param {Array} [array=[]] The array to copy values to. * @returns {Array} Returns `array`. */ function copyArray(source, array) { var index = -1, length = source.length; array || (array = Array(length)); while (++index < length) { array[index] = source[index]; } return array; } module.exports = copyArray; /***/ }), /***/ 1149: /***/ (function(module, exports, __webpack_require__) { var baseCreate = __webpack_require__(1159), getPrototype = __webpack_require__(1026), isPrototype = __webpack_require__(896); /** * Initializes an object clone. * * @private * @param {Object} object The object to clone. * @returns {Object} Returns the initialized clone. */ function initCloneObject(object) { return (typeof object.constructor == 'function' && !isPrototype(object)) ? baseCreate(getPrototype(object)) : {}; } module.exports = initCloneObject; /***/ }), /***/ 1150: /***/ (function(module, exports, __webpack_require__) { var baseGetTag = __webpack_require__(296), getPrototype = __webpack_require__(1026), isObjectLike = __webpack_require__(293); /** `Object#toString` result references. */ var objectTag = '[object Object]'; /** Used for built-in method references. */ var funcProto = Function.prototype, objectProto = Object.prototype; /** Used to resolve the decompiled source of functions. */ var funcToString = funcProto.toString; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; /** Used to infer the `Object` constructor. */ var objectCtorString = funcToString.call(Object); /** * Checks if `value` is a plain object, that is, an object created by the * `Object` constructor or one with a `[[Prototype]]` of `null`. * * @static * @memberOf _ * @since 0.8.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. * @example * * function Foo() { * this.a = 1; * } * * _.isPlainObject(new Foo); * // => false * * _.isPlainObject([1, 2, 3]); * // => false * * _.isPlainObject({ 'x': 0, 'y': 0 }); * // => true * * _.isPlainObject(Object.create(null)); * // => true */ function isPlainObject(value) { if (!isObjectLike(value) || baseGetTag(value) != objectTag) { return false; } var proto = getPrototype(value); if (proto === null) { return true; } var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString; } module.exports = isPlainObject; /***/ }), /***/ 1158: /***/ (function(module, exports) { /** * Creates a base function for methods like `_.forIn` and `_.forOwn`. * * @private * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new base function. */ function createBaseFor(fromRight) { return function(object, iteratee, keysFunc) { var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; while (length--) { var key = props[fromRight ? length : ++index]; if (iteratee(iterable[key], key, iterable) === false) { break; } } return object; }; } module.exports = createBaseFor; /***/ }), /***/ 1159: /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__(163); /** Built-in value references. */ var objectCreate = Object.create; /** * The base implementation of `_.create` without support for assigning * properties to the created object. * * @private * @param {Object} proto The object to inherit from. * @returns {Object} Returns the new object. */ var baseCreate = (function() { function object() {} return function(proto) { if (!isObject(proto)) { return {}; } if (objectCreate) { return objectCreate(proto); } object.prototype = proto; var result = new object; object.prototype = undefined; return result; }; }()); module.exports = baseCreate; /***/ }), /***/ 1160: /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__(163), isPrototype = __webpack_require__(896), nativeKeysIn = __webpack_require__(1161); /** Used for built-in method references. */ var objectProto = Object.prototype; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; /** * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. */ function baseKeysIn(object) { if (!isObject(object)) { return nativeKeysIn(object); } var isProto = isPrototype(object), result = []; for (var key in object) { if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { result.push(key); } } return result; } module.exports = baseKeysIn; /***/ }), /***/ 1161: /***/ (function(module, exports) { /** * This function is like * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) * except that it includes inherited enumerable properties. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. */ function nativeKeysIn(object) { var result = []; if (object != null) { for (var key in Object(object)) { result.push(key); } } return result; } module.exports = nativeKeysIn; /***/ }), /***/ 1212: /***/ (function(module, exports, __webpack_require__) { var Stack = __webpack_require__(855), assignMergeValue = __webpack_require__(1050), baseFor = __webpack_require__(1145), baseMergeDeep = __webpack_require__(1213), isObject = __webpack_require__(163), keysIn = __webpack_require__(1027), safeGet = __webpack_require__(1051); /** * The base implementation of `_.merge` without support for multiple sources. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {number} srcIndex The index of `source`. * @param {Function} [customizer] The function to customize merged values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMerge(object, source, srcIndex, customizer, stack) { if (object === source) { return; } baseFor(source, function(srcValue, key) { stack || (stack = new Stack); if (isObject(srcValue)) { baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); } else { var newValue = customizer ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) : undefined; if (newValue === undefined) { newValue = srcValue; } assignMergeValue(object, key, newValue); } }, keysIn); } module.exports = baseMerge; /***/ }), /***/ 1213: /***/ (function(module, exports, __webpack_require__) { var assignMergeValue = __webpack_require__(1050), cloneBuffer = __webpack_require__(1146), cloneTypedArray = __webpack_require__(1147), copyArray = __webpack_require__(1148), initCloneObject = __webpack_require__(1149), isArguments = __webpack_require__(833), isArray = __webpack_require__(815), isArrayLikeObject = __webpack_require__(1214), isBuffer = __webpack_require__(846), isFunction = __webpack_require__(829), isObject = __webpack_require__(163), isPlainObject = __webpack_require__(1150), isTypedArray = __webpack_require__(847), safeGet = __webpack_require__(1051), toPlainObject = __webpack_require__(1215); /** * A specialized version of `baseMerge` for arrays and objects which performs * deep merges and tracks traversed objects enabling objects with circular * references to be merged. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {string} key The key of the value to merge. * @param {number} srcIndex The index of `source`. * @param {Function} mergeFunc The function to merge values. * @param {Function} [customizer] The function to customize assigned values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue); if (stacked) { assignMergeValue(object, key, stacked); return; } var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined; var isCommon = newValue === undefined; if (isCommon) { var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue); newValue = srcValue; if (isArr || isBuff || isTyped) { if (isArray(objValue)) { newValue = objValue; } else if (isArrayLikeObject(objValue)) { newValue = copyArray(objValue); } else if (isBuff) { isCommon = false; newValue = cloneBuffer(srcValue, true); } else if (isTyped) { isCommon = false; newValue = cloneTypedArray(srcValue, true); } else { newValue = []; } } else if (isPlainObject(srcValue) || isArguments(srcValue)) { newValue = objValue; if (isArguments(objValue)) { newValue = toPlainObject(objValue); } else if (!isObject(objValue) || isFunction(objValue)) { newValue = initCloneObject(srcValue); } } else { isCommon = false; } } if (isCommon) { // Recursively merge objects and arrays (susceptible to call stack limits). stack.set(srcValue, newValue); mergeFunc(newValue, srcValue, srcIndex, customizer, stack); stack['delete'](srcValue); } assignMergeValue(object, key, newValue); } module.exports = baseMergeDeep; /***/ }), /***/ 1214: /***/ (function(module, exports, __webpack_require__) { var isArrayLike = __webpack_require__(844), isObjectLike = __webpack_require__(293); /** * This method is like `_.isArrayLike` except that it also checks if `value` * is an object. * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is an array-like object, * else `false`. * @example * * _.isArrayLikeObject([1, 2, 3]); * // => true * * _.isArrayLikeObject(document.body.children); * // => true * * _.isArrayLikeObject('abc'); * // => false * * _.isArrayLikeObject(_.noop); * // => false */ function isArrayLikeObject(value) { return isObjectLike(value) && isArrayLike(value); } module.exports = isArrayLikeObject; /***/ }), /***/ 1215: /***/ (function(module, exports, __webpack_require__) { var copyObject = __webpack_require__(1124), keysIn = __webpack_require__(1027); /** * Converts `value` to a plain object flattening inherited enumerable string * keyed properties of `value` to own properties of the plain object. * * @static * @memberOf _ * @since 3.0.0 * @category Lang * @param {*} value The value to convert. * @returns {Object} Returns the converted plain object. * @example * * function Foo() { * this.b = 2; * } * * Foo.prototype.c = 3; * * _.assign({ 'a': 1 }, new Foo); * // => { 'a': 1, 'b': 2 } * * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); * // => { 'a': 1, 'b': 2, 'c': 3 } */ function toPlainObject(value) { return copyObject(value, keysIn(value)); } module.exports = toPlainObject; /***/ }), /***/ 1216: /***/ (function(module, exports, __webpack_require__) { var baseRest = __webpack_require__(1217), isIterateeCall = __webpack_require__(1224); /** * Creates a function like `_.assign`. * * @private * @param {Function} assigner The function to assign values. * @returns {Function} Returns the new assigner function. */ function createAssigner(assigner) { return baseRest(function(object, sources) { var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined, guard = length > 2 ? sources[2] : undefined; customizer = (assigner.length > 3 && typeof customizer == 'function') ? (length--, customizer) : undefined; if (guard && isIterateeCall(sources[0], sources[1], guard)) { customizer = length < 3 ? undefined : customizer; length = 1; } object = Object(object); while (++index < length) { var source = sources[index]; if (source) { assigner(object, source, index, customizer); } } return object; }); } module.exports = createAssigner; /***/ }), /***/ 1217: /***/ (function(module, exports, __webpack_require__) { var identity = __webpack_require__(897), overRest = __webpack_require__(1218), setToString = __webpack_require__(1220); /** * The base implementation of `_.rest` which doesn't validate or coerce arguments. * * @private * @param {Function} func The function to apply a rest parameter to. * @param {number} [start=func.length-1] The start position of the rest parameter. * @returns {Function} Returns the new function. */ function baseRest(func, start) { return setToString(overRest(func, start, identity), func + ''); } module.exports = baseRest; /***/ }), /***/ 1218: /***/ (function(module, exports, __webpack_require__) { var apply = __webpack_require__(1219); /* Built-in method references for those with the same name as other `lodash` methods. */ var nativeMax = Math.max; /** * A specialized version of `baseRest` which transforms the rest array. * * @private * @param {Function} func The function to apply a rest parameter to. * @param {number} [start=func.length-1] The start position of the rest parameter. * @param {Function} transform The rest array transform. * @returns {Function} Returns the new function. */ function overRest(func, start, transform) { start = nativeMax(start === undefined ? (func.length - 1) : start, 0); return function() { var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length); while (++index < length) { array[index] = args[start + index]; } index = -1; var otherArgs = Array(start + 1); while (++index < start) { otherArgs[index] = args[index]; } otherArgs[start] = transform(array); return apply(func, this, otherArgs); }; } module.exports = overRest; /***/ }), /***/ 1219: /***/ (function(module, exports) { /** * A faster alternative to `Function#apply`, this function invokes `func` * with the `this` binding of `thisArg` and the arguments of `args`. * * @private * @param {Function} func The function to invoke. * @param {*} thisArg The `this` binding of `func`. * @param {Array} args The arguments to invoke `func` with. * @returns {*} Returns the result of `func`. */ function apply(func, thisArg, args) { switch (args.length) { case 0: return func.call(thisArg); case 1: return func.call(thisArg, args[0]); case 2: return func.call(thisArg, args[0], args[1]); case 3: return func.call(thisArg, args[0], args[1], args[2]); } return func.apply(thisArg, args); } module.exports = apply; /***/ }), /***/ 1220: /***/ (function(module, exports, __webpack_require__) { var baseSetToString = __webpack_require__(1221), shortOut = __webpack_require__(1223); /** * Sets the `toString` method of `func` to return `string`. * * @private * @param {Function} func The function to modify. * @param {Function} string The `toString` result. * @returns {Function} Returns `func`. */ var setToString = shortOut(baseSetToString); module.exports = setToString; /***/ }), /***/ 1221: /***/ (function(module, exports, __webpack_require__) { var constant = __webpack_require__(1222), defineProperty = __webpack_require__(852), identity = __webpack_require__(897); /** * The base implementation of `setToString` without support for hot loop shorting. * * @private * @param {Function} func The function to modify. * @param {Function} string The `toString` result. * @returns {Function} Returns `func`. */ var baseSetToString = !defineProperty ? identity : function(func, string) { return defineProperty(func, 'toString', { 'configurable': true, 'enumerable': false, 'value': constant(string), 'writable': true }); }; module.exports = baseSetToString; /***/ }), /***/ 1222: /***/ (function(module, exports) { /** * Creates a function that returns `value`. * * @static * @memberOf _ * @since 2.4.0 * @category Util * @param {*} value The value to return from the new function. * @returns {Function} Returns the new constant function. * @example * * var objects = _.times(2, _.constant({ 'a': 1 })); * * console.log(objects); * // => [{ 'a': 1 }, { 'a': 1 }] * * console.log(objects[0] === objects[1]); * // => true */ function constant(value) { return function() { return value; }; } module.exports = constant; /***/ }), /***/ 1223: /***/ (function(module, exports) { /** Used to detect hot functions by number of calls within a span of milliseconds. */ var HOT_COUNT = 800, HOT_SPAN = 16; /* Built-in method references for those with the same name as other `lodash` methods. */ var nativeNow = Date.now; /** * Creates a function that'll short out and invoke `identity` instead * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` * milliseconds. * * @private * @param {Function} func The function to restrict. * @returns {Function} Returns the new shortable function. */ function shortOut(func) { var count = 0, lastCalled = 0; return function() { var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled); lastCalled = stamp; if (remaining > 0) { if (++count >= HOT_COUNT) { return arguments[0]; } } else { count = 0; } return func.apply(undefined, arguments); }; } module.exports = shortOut; /***/ }), /***/ 1224: /***/ (function(module, exports, __webpack_require__) { var eq = __webpack_require__(820), isArrayLike = __webpack_require__(844), isIndex = __webpack_require__(823), isObject = __webpack_require__(163); /** * Checks if the given arguments are from an iteratee call. * * @private * @param {*} value The potential iteratee value argument. * @param {*} index The potential iteratee index or key argument. * @param {*} object The potential iteratee object argument. * @returns {boolean} Returns `true` if the arguments are from an iteratee call, * else `false`. */ function isIterateeCall(value, index, object) { if (!isObject(object)) { return false; } var type = typeof index; if (type == 'number' ? (isArrayLike(object) && isIndex(index, object.length)) : (type == 'string' && index in object) ) { return eq(object[index], value); } return false; } module.exports = isIterateeCall; /***/ }), /***/ 1225: /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports["default"] = void 0; var React = _interopRequireWildcard(__webpack_require__(0)); var _KeyCode = _interopRequireDefault(__webpack_require__(302)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } function _extends() { _extends = Object.assign || 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 _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); return Constructor; } function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 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 } }); if (superClass) _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var __rest = void 0 && (void 0).__rest || function (s, e) { var t = {}; for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; } if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t; }; /** * Wrap of sub component which need use as Button capacity (like Icon component). * This helps accessibility reader to tread as a interactive button to operation. */ var inlineStyle = { border: 0, background: 'transparent', padding: 0, lineHeight: 'inherit', display: 'inline-block' }; var TransButton = /*#__PURE__*/ function (_React$Component) { _inherits(TransButton, _React$Component); function TransButton() { var _this; _classCallCheck(this, TransButton); _this = _possibleConstructorReturn(this, _getPrototypeOf(TransButton).apply(this, arguments)); _this.onKeyDown = function (event) { var keyCode = event.keyCode; if (keyCode === _KeyCode["default"].ENTER) { event.preventDefault(); } }; _this.onKeyUp = function (event) { var keyCode = event.keyCode; var onClick = _this.props.onClick; if (keyCode === _KeyCode["default"].ENTER && onClick) { onClick(); } }; _this.setRef = function (btn) { _this.div = btn; }; return _this; } _createClass(TransButton, [{ key: "focus", value: function focus() { if (this.div) { this.div.focus(); } } }, { key: "blur", value: function blur() { if (this.div) { this.div.blur(); } } }, { key: "render", value: function render() { var _a = this.props, style = _a.style, noStyle = _a.noStyle, restProps = __rest(_a, ["style", "noStyle"]); return React.createElement("div", _extends({ role: "button", tabIndex: 0, ref: this.setRef }, restProps, { onKeyDown: this.onKeyDown, onKeyUp: this.onKeyUp, style: _extends(_extends({}, !noStyle ? inlineStyle : null), style) })); } }]); return TransButton; }(React.Component); var _default = TransButton; exports["default"] = _default; //# sourceMappingURL=transButton.js.map /***/ }), /***/ 1227: /***/ (function(module, exports, __webpack_require__) { // style-loader: Adds some css to the DOM by adding a