text: "use strict";
  
  var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
  
  var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
  
  var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
  
  var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
  
  var React = _interopRequireWildcard(require("react"));
  
  var _classnames = _interopRequireDefault(require("classnames"));
  
  var _ref3 = require("rc-util/lib/ref");
  
  var _valueUtil = require("../utils/valueUtil");
  
  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) { (0, _defineProperty2.default)(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 isRenderCell(data) {
    return data && (0, _typeof2.default)(data) === 'object' && !Array.isArray(data) && !React.isValidElement(data);
  }
  
  function isRefComponent(component) {
    // String tag component also support ref
    if (typeof component === 'string') {
      return true;
    }
  
    return (0, _ref3.supportRef)(component);
  }
  
  function Cell(_ref, ref) {
    var _classNames;
  
    var prefixCls = _ref.prefixCls,
        className = _ref.className,
        record = _ref.record,
        index = _ref.index,
        dataIndex = _ref.dataIndex,
        render = _ref.render,
        children = _ref.children,
        _ref$component = _ref.component,
        Component = _ref$component === void 0 ? 'td' : _ref$component,
        colSpan = _ref.colSpan,
        rowSpan = _ref.rowSpan,
        fixLeft = _ref.fixLeft,
        fixRight = _ref.fixRight,
        firstFixLeft = _ref.firstFixLeft,
        lastFixLeft = _ref.lastFixLeft,
        firstFixRight = _ref.firstFixRight,
        lastFixRight = _ref.lastFixRight,
        appendNode = _ref.appendNode,
        _ref$additionalProps = _ref.additionalProps,
        additionalProps = _ref$additionalProps === void 0 ? {} : _ref$additionalProps,
        ellipsis = _ref.ellipsis,
        align = _ref.align,
        rowType = _ref.rowType,
        isSticky = _ref.isSticky;
    var cellPrefixCls = "".concat(prefixCls, "-cell"); // ==================== Child Node ====================
  
    var cellProps;
    var childNode;
  
    if (children) {
      childNode = children;
    } else {
      var value = (0, _valueUtil.getPathValue)(record, dataIndex); // Customize render node
  
      childNode = value;
  
      if (render) {
        var renderData = render(value, record, index);
  
        if (isRenderCell(renderData)) {
          childNode = renderData.children;
          cellProps = renderData.props;
        } else {
          childNode = renderData;
        }
      }
    } // Not crash if final `childNode` is not validate ReactNode
  
  
    if ((0, _typeof2.default)(childNode) === 'object' && !Array.isArray(childNode) && !React.isValidElement(childNode)) {
      childNode = null;
    }
  
    if (ellipsis && (lastFixLeft || firstFixRight)) {
      childNode = React.createElement("span", {
        className: "".concat(cellPrefixCls, "-content")
      }, childNode);
    }
  
    var _ref2 = cellProps || {},
        cellColSpan = _ref2.colSpan,
        cellRowSpan = _ref2.rowSpan,
        cellStyle = _ref2.style,
        cellClassName = _ref2.className,
        restCellProps = (0, _objectWithoutProperties2.default)(_ref2, ["colSpan", "rowSpan", "style", "className"]);
  
    var mergedColSpan = cellColSpan !== undefined ? cellColSpan : colSpan;
    var mergedRowSpan = cellRowSpan !== undefined ? cellRowSpan : rowSpan;
  
    if (mergedColSpan === 0 || mergedRowSpan === 0) {
      return null;
    } // ====================== Fixed =======================
  
  
    var fixedStyle = {};
    var isFixLeft = typeof fixLeft === 'number';
    var isFixRight = typeof fixRight === 'number';
  
    if (isFixLeft) {
      fixedStyle.position = 'sticky';
      fixedStyle.left = fixLeft;
    }
  
    if (isFixRight) {
      fixedStyle.position = 'sticky';
      fixedStyle.right = fixRight;
    } // ====================== Align =======================
  
  
    var alignStyle = {};
  
    if (align) {
      alignStyle.textAlign = align;
    } // ====================== Render ======================
  
  
    var title;
    var ellipsisConfig = ellipsis === true ? {
      showTitle: true
    } : ellipsis;
  
    if (ellipsisConfig && (ellipsisConfig.showTitle || rowType === 'header')) {
      if (typeof childNode === 'string' || typeof childNode === 'number') {
        title = childNode.toString();
      } else if (React.isValidElement(childNode) && typeof childNode.props.children === 'string') {
        title = childNode.props.children;
      }
    }
  
    var componentProps = _objectSpread(_objectSpread(_objectSpread({
      title: title
    }, restCellProps), additionalProps), {}, {
      colSpan: mergedColSpan && mergedColSpan !== 1 ? mergedColSpan : null,
      rowSpan: mergedRowSpan && mergedRowSpan !== 1 ? mergedRowSpan : null,
      className: (0, _classnames.default)(cellPrefixCls, className, (_classNames = {}, (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-left"), isFixLeft), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-left-first"), firstFixLeft), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-left-last"), lastFixLeft), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-right"), isFixRight), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-right-first"), firstFixRight), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-right-last"), lastFixRight), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-ellipsis"), ellipsis), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-with-append"), appendNode), (0, _defineProperty2.default)(_classNames, "".concat(cellPrefixCls, "-fix-sticky"), (isFixLeft || isFixRight) && isSticky), _classNames), additionalProps.className, cellClassName),
      style: _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, additionalProps.style), alignStyle), fixedStyle), cellStyle),
      ref: isRefComponent(Component) ? ref : null
    });
  
    return React.createElement(Component, Object.assign({}, componentProps), appendNode, childNode);
  }
  
  var RefCell = React.forwardRef(Cell);
  RefCell.displayName = 'Cell';
  var MemoCell = React.memo(RefCell, function (prev, next) {
    if (next.shouldCellUpdate) {
      return !next.shouldCellUpdate(next.record, prev.record);
    }
  
    return false;
  });
  var _default = MemoCell;
  exports.default = _default;