choerodon-ui/pro/es/table/utils.js

An enterprise-class UI design language and React-based implementation

import _typeof from "@babel/runtime/helpers/typeof";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _extends from "@babel/runtime/helpers/extends";
import React, { isValidElement } from 'react';
import isString from 'lodash/isString';
import warning from '../../../es/_util/warning';
import ObserverCheckBox from '../check-box/CheckBox';
import { FieldType, RecordStatus } from '../data-set/enum';
import ObserverSelect from '../select/Select';
import TreeSelect from '../tree-select/TreeSelect';
import Option from '../option/Option';
import Lov from '../lov/Lov';
import ObserverNumberField from '../number-field/NumberField';
import Currency from '../currency/Currency';
import DatePicker from '../date-picker/DatePicker';
import DateTimePicker from '../date-time-picker/DateTimePicker';
import TimePicker from '../time-picker/TimePicker';
import WeekPicker from '../week-picker/WeekPicker';
import MonthPicker from '../month-picker/MonthPicker';
import YearPicker from '../year-picker/YearPicker';
import ObserverTextField from '../text-field/TextField';
import { ColumnAlign, ColumnLock, TablePaginationPosition } from './enum';
import IntlField from '../intl-field/IntlField';
import UrlField from '../url-field/UrlField';
import EmailField from '../email-field/EmailField';
import ColorPicker from '../color-picker/ColorPicker';
import Output from '../output/Output';
import { $l } from '../locale-context';
export function getEditorByField(field, isQueryField, isFlat) {
  var lookupCode = field.get('lookupCode');
  var lookupUrl = field.get('lookupUrl');
  var lovCode = field.get('lovCode');
  var multiLine = field.get('multiLine');
  var type = field.type,
      name = field.name;
  var flatProps = isFlat ? {
    isFlat: isFlat,
    maxTagCount: 2,
    maxTagTextLength: 4
  } : {};

  if (lookupCode || isString(lookupUrl) || type !== FieldType.object && (lovCode || field.options)) {
    if (field.get('parentField')) {
      return React.createElement(TreeSelect, _extends({}, flatProps));
    }

    return React.createElement(ObserverSelect, _extends({}, flatProps));
  }

  if (lovCode) {
    return React.createElement(Lov, _extends({}, flatProps));
  }

  if (multiLine) {
    return React.createElement(Output, null);
  }

  switch (type) {
    case FieldType["boolean"]:
      return isQueryField ? React.createElement(ObserverSelect, {
        clearButton: true
      }, React.createElement(Option, {
        value: true
      }, $l('Table', 'query_option_yes')), React.createElement(Option, {
        value: false
      }, $l('Table', 'query_option_no'))) : React.createElement(ObserverCheckBox, null);

    case FieldType.number:
      return React.createElement(ObserverNumberField, _extends({}, flatProps));

    case FieldType.currency:
      return React.createElement(Currency, {
        isFlat: isFlat
      });

    case FieldType.date:
      return React.createElement(DatePicker, {
        isFlat: isFlat
      });

    case FieldType.dateTime:
      return React.createElement(DateTimePicker, {
        isFlat: isFlat
      });

    case FieldType.time:
      return React.createElement(TimePicker, {
        isFlat: isFlat
      });

    case FieldType.week:
      return React.createElement(WeekPicker, {
        isFlat: isFlat
      });

    case FieldType.month:
      return React.createElement(MonthPicker, {
        isFlat: isFlat
      });

    case FieldType.year:
      return React.createElement(YearPicker, {
        isFlat: isFlat
      });

    case FieldType.intl:
      return React.createElement(IntlField, {
        isFlat: isFlat
      });

    case FieldType.email:
      return React.createElement(EmailField, {
        isFlat: isFlat
      });

    case FieldType.url:
      return React.createElement(UrlField, {
        isFlat: isFlat
      });

    case FieldType.color:
      return React.createElement(ColorPicker, {
        isFlat: isFlat
      });

    case FieldType.string:
      return React.createElement(ObserverTextField, {
        isFlat: isFlat
      });

    default:
      warning(false, "Table auto editor: No editor exists on the field<".concat(name, ">'s type<").concat(type, ">, so use the TextField as default editor"));
      return React.createElement(ObserverTextField, {
        isFlat: isFlat
      });
  }
}
export function getAlignByField(field) {
  if (field) {
    var type = field.type;

    switch (type) {
      case FieldType.number:
        return ColumnAlign.right;

      case FieldType["boolean"]:
        return ColumnAlign.center;

      default:
    }
  }
}
export function getPlacementByAlign(align) {
  if (align === ColumnAlign.center) {
    return 'bottom';
  }

  if (align === ColumnAlign.right) {
    return 'bottomRight';
  }

  return 'bottomLeft';
}
export function getEditorByColumnAndRecord(column, record) {
  var name = column.name,
      editor = column.editor;

  if (record) {
    var cellEditor = editor;

    if (typeof editor === 'function') {
      cellEditor = editor(record, name);
    }

    if (cellEditor === true) {
      var field = record.getField(name);

      if (field) {
        if (!field.get('unique') || field.get('multiple') || field.get('range') || record.status === RecordStatus.add) {
          return getEditorByField(field);
        }
      }
    }

    if (isValidElement(cellEditor)) {
      return cellEditor;
    }
  }
}
export function isInCellEditor(element) {
  if (element) {
    return !!element.type.__IS_IN_CELL_EDITOR;
  }

  return false;
}
var STICKY_SUPPORT;
export function isStickySupport() {
  if (STICKY_SUPPORT !== undefined) {
    return STICKY_SUPPORT;
  }

  if (typeof window !== 'undefined') {
    var vendorList = ['', '-webkit-', '-ms-', '-moz-', '-o-'];
    var stickyElement = document.createElement('div');
    STICKY_SUPPORT = vendorList.some(function (vendor) {
      stickyElement.style.position = "".concat(vendor, "sticky");

      if (stickyElement.style.position !== '') {
        return true;
      }

      return false;
    });
    return STICKY_SUPPORT;
  }

  return true;
}
export function findCell(tableStore, name, lock, record) {
  var node = tableStore.node,
      dataSet = tableStore.dataSet,
      overflowX = tableStore.overflowX,
      currentEditRecord = tableStore.currentEditRecord,
      prefixCls = tableStore.prefixCls;
  var current = record || currentEditRecord || dataSet.current;

  if (name !== undefined && current && node.element) {
    var wrapperSelector = !isStickySupport() && overflowX && lock ? ".".concat(prefixCls, "-fixed-").concat(lock === true ? ColumnLock.left : lock, " ") : '';
    var selector = "".concat(wrapperSelector, "tr[data-index=\"").concat(current.id, "\"] td[data-index=\"").concat(name, "\"] span.").concat(prefixCls, "-cell-inner");
    return node.element.querySelector(selector);
  }
}
export function findFirstFocusableElement(node) {
  if (node.children) {
    var found;

    _toConsumableArray(node.children).some(function (child) {
      if (child.tabIndex > -1) {
        found = child;
      } else {
        found = findFirstFocusableElement(child);
      }

      return !!found;
    });

    return found;
  }
} // 用于校验定位 focus 第一个非法单元格

export function findFirstFocusableInvalidElement(node) {
  if (node.children) {
    var found;

    _toConsumableArray(node.children).some(function (child) {
      if (child.tabIndex > -1 && child.className.includes('invalid')) {
        found = child;
      } else {
        found = findFirstFocusableInvalidElement(child);
      }

      return !!found;
    });

    return found;
  }
}
export function isCanEdictingRow(element) {
  var sibling = element;

  if (!sibling || 'index' in sibling.dataset && !sibling.getAttributeNodeNS('', 'disabled') && (!document.defaultView || document.defaultView.getComputedStyle(sibling).display !== 'none')) {
    return true;
  }

  return false;
}
export function findIndexedSibling(element, direction) {
  var sibling = direction > 0 ? element.nextElementSibling : element.previousElementSibling;

  if (isCanEdictingRow(element)) {
    return sibling;
  }

  return findIndexedSibling(sibling, direction);
}
export function isDisabledRow(record) {
  return record.isCached || record.status === RecordStatus["delete"];
}
export function isSelectedRow(record) {
  return record.isSelected;
}
export function getHeader(column, dataSet) {
  var header = column.header,
      name = column.name,
      title = column.title;

  if (typeof header === 'function') {
    return header(dataSet, name, title);
  }

  if (title !== undefined) {
    return title;
  }

  if (header !== undefined) {
    return header;
  }

  var field = dataSet.getField(name);

  if (field) {
    return field.get('label');
  }
}
export function getColumnKey(_ref) {
  var name = _ref.name,
      key = _ref.key;
  return key || name;
}
export function getColumnLock(lock) {
  if (lock === true) {
    return ColumnLock.left;
  }

  if (lock) {
    return lock;
  }

  return false;
}
export function getPaginationPosition(pagination) {
  if (pagination) {
    var position = pagination.position;

    if (position) {
      return position;
    }
  }

  return TablePaginationPosition.bottom;
}
export function getHeight(el) {
  return el.getBoundingClientRect().height;
}
export function isDropresult(dropResult) {
  if (dropResult && dropResult.destination) {
    return typeof dropResult.source.index === 'number' && _typeof(dropResult.destination) === 'object' && typeof dropResult.destination.index === 'number';
  }

  return false;
}
export function isDraggingStyle(style) {
  return style ? 'left' in style : false;
}
//# sourceMappingURL=utils.js.map