1

admin/node_modules/element-plus/es/components/table/src/util.mjs

@@ -0,0 +1,439 @@
+import { createVNode, render, isVNode } from 'vue';
+import { merge, flatMap, castArray, get, isNull } from 'lodash-unified';
+import { ElTooltip } from '../../tooltip/index.mjs';
+import { isArray, isString, isFunction, hasOwn, isObject } from '@vue/shared';
+import { throwError } from '../../../utils/error.mjs';
+import { isUndefined, isNumber, isBoolean } from '../../../utils/types.mjs';
+import { getProp } from '../../../utils/objects.mjs';
+
+const getCell = function(event) {
+  var _a;
+  return (_a = event.target) == null ? void 0 : _a.closest("td");
+};
+const orderBy = function(array, sortKey, reverse, sortMethod, sortBy) {
+  if (!sortKey && !sortMethod && (!sortBy || isArray(sortBy) && !sortBy.length)) {
+    return array;
+  }
+  if (isString(reverse)) {
+    reverse = reverse === "descending" ? -1 : 1;
+  } else {
+    reverse = reverse && reverse < 0 ? -1 : 1;
+  }
+  const getKey = sortMethod ? null : function(value, index) {
+    if (sortBy) {
+      return flatMap(castArray(sortBy), (by) => {
+        if (isString(by)) {
+          return get(value, by);
+        } else {
+          return by(value, index, array);
+        }
+      });
+    }
+    if (sortKey !== "$key") {
+      if (isObject(value) && "$value" in value)
+        value = value.$value;
+    }
+    return [
+      isObject(value) ? sortKey ? get(value, sortKey) : null : value
+    ];
+  };
+  const compare = function(a, b) {
+    var _a, _b, _c, _d, _e, _f;
+    if (sortMethod) {
+      return sortMethod(a.value, b.value);
+    }
+    for (let i = 0, len = (_b = (_a = a.key) == null ? void 0 : _a.length) != null ? _b : 0; i < len; i++) {
+      if (((_c = a.key) == null ? void 0 : _c[i]) < ((_d = b.key) == null ? void 0 : _d[i])) {
+        return -1;
+      }
+      if (((_e = a.key) == null ? void 0 : _e[i]) > ((_f = b.key) == null ? void 0 : _f[i])) {
+        return 1;
+      }
+    }
+    return 0;
+  };
+  return array.map((value, index) => {
+    return {
+      value,
+      index,
+      key: getKey ? getKey(value, index) : null
+    };
+  }).sort((a, b) => {
+    let order = compare(a, b);
+    if (!order) {
+      order = a.index - b.index;
+    }
+    return order * +reverse;
+  }).map((item) => item.value);
+};
+const getColumnById = function(table, columnId) {
+  let column = null;
+  table.columns.forEach((item) => {
+    if (item.id === columnId) {
+      column = item;
+    }
+  });
+  return column;
+};
+const getColumnByKey = function(table, columnKey) {
+  let column = null;
+  for (let i = 0; i < table.columns.length; i++) {
+    const item = table.columns[i];
+    if (item.columnKey === columnKey) {
+      column = item;
+      break;
+    }
+  }
+  if (!column)
+    throwError("ElTable", `No column matching with column-key: ${columnKey}`);
+  return column;
+};
+const getColumnByCell = function(table, cell, namespace) {
+  const matches = (cell.className || "").match(new RegExp(`${namespace}-table_[^\\s]+`, "gm"));
+  if (matches) {
+    return getColumnById(table, matches[0]);
+  }
+  return null;
+};
+const getRowIdentity = (row, rowKey) => {
+  if (!row)
+    throw new Error("Row is required when get row identity");
+  if (isString(rowKey)) {
+    if (!rowKey.includes(".")) {
+      return `${row[rowKey]}`;
+    }
+    const key = rowKey.split(".");
+    let current = row;
+    for (const element of key) {
+      current = current[element];
+    }
+    return `${current}`;
+  } else if (isFunction(rowKey)) {
+    return rowKey.call(null, row);
+  }
+  return "";
+};
+const getKeysMap = function(array, rowKey, flatten = false, childrenKey = "children") {
+  const data = array || [];
+  const arrayMap = {};
+  data.forEach((row, index) => {
+    arrayMap[getRowIdentity(row, rowKey)] = { row, index };
+    if (flatten) {
+      const children = row[childrenKey];
+      if (isArray(children)) {
+        Object.assign(arrayMap, getKeysMap(children, rowKey, true, childrenKey));
+      }
+    }
+  });
+  return arrayMap;
+};
+function mergeOptions(defaults, config) {
+  const options = {};
+  let key;
+  for (key in defaults) {
+    options[key] = defaults[key];
+  }
+  for (key in config) {
+    if (hasOwn(config, key)) {
+      const value = config[key];
+      if (!isUndefined(value)) {
+        options[key] = value;
+      }
+    }
+  }
+  return options;
+}
+function parseWidth(width) {
+  if (width === "")
+    return width;
+  if (!isUndefined(width)) {
+    width = Number.parseInt(width, 10);
+    if (Number.isNaN(width)) {
+      width = "";
+    }
+  }
+  return width;
+}
+function parseMinWidth(minWidth) {
+  if (minWidth === "")
+    return minWidth;
+  if (!isUndefined(minWidth)) {
+    minWidth = parseWidth(minWidth);
+    if (Number.isNaN(minWidth)) {
+      minWidth = 80;
+    }
+  }
+  return minWidth;
+}
+function parseHeight(height) {
+  if (isNumber(height)) {
+    return height;
+  }
+  if (isString(height)) {
+    if (/^\d+(?:px)?$/.test(height)) {
+      return Number.parseInt(height, 10);
+    } else {
+      return height;
+    }
+  }
+  return null;
+}
+function compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
+}
+function toggleRowStatus(statusArr, row, newVal, tableTreeProps, selectable, rowIndex, rowKey) {
+  let _rowIndex = rowIndex != null ? rowIndex : 0;
+  let changed = false;
+  const getIndex = () => {
+    if (!rowKey) {
+      return statusArr.indexOf(row);
+    }
+    const id = getRowIdentity(row, rowKey);
+    return statusArr.findIndex((item) => getRowIdentity(item, rowKey) === id);
+  };
+  const index = getIndex();
+  const included = index !== -1;
+  const isRowSelectable = selectable == null ? void 0 : selectable.call(null, row, _rowIndex);
+  const toggleStatus = (type) => {
+    if (type === "add") {
+      statusArr.push(row);
+    } else {
+      statusArr.splice(index, 1);
+    }
+    changed = true;
+  };
+  const getChildrenCount = (row2) => {
+    let count = 0;
+    const children = (tableTreeProps == null ? void 0 : tableTreeProps.children) && row2[tableTreeProps.children];
+    if (children && isArray(children)) {
+      count += children.length;
+      children.forEach((item) => {
+        count += getChildrenCount(item);
+      });
+    }
+    return count;
+  };
+  if (!selectable || isRowSelectable) {
+    if (isBoolean(newVal)) {
+      if (newVal && !included) {
+        toggleStatus("add");
+      } else if (!newVal && included) {
+        toggleStatus("remove");
+      }
+    } else {
+      included ? toggleStatus("remove") : toggleStatus("add");
+    }
+  }
+  if (!(tableTreeProps == null ? void 0 : tableTreeProps.checkStrictly) && (tableTreeProps == null ? void 0 : tableTreeProps.children) && isArray(row[tableTreeProps.children])) {
+    row[tableTreeProps.children].forEach((item) => {
+      const childChanged = toggleRowStatus(statusArr, item, newVal != null ? newVal : !included, tableTreeProps, selectable, _rowIndex + 1, rowKey);
+      _rowIndex += getChildrenCount(item) + 1;
+      if (childChanged) {
+        changed = childChanged;
+      }
+    });
+  }
+  return changed;
+}
+function walkTreeNode(root, cb, childrenKey = "children", lazyKey = "hasChildren", lazy = false) {
+  const isNil = (array) => !(isArray(array) && array.length);
+  function _walker(parent, children, level) {
+    cb(parent, children, level);
+    children.forEach((item) => {
+      if (item[lazyKey] && lazy) {
+        cb(item, null, level + 1);
+        return;
+      }
+      const children2 = item[childrenKey];
+      if (!isNil(children2)) {
+        _walker(item, children2, level + 1);
+      }
+    });
+  }
+  root.forEach((item) => {
+    if (item[lazyKey] && lazy) {
+      cb(item, null, 0);
+      return;
+    }
+    const children = item[childrenKey];
+    if (!isNil(children)) {
+      _walker(item, children, 0);
+    }
+  });
+}
+const getTableOverflowTooltipProps = (props, innerText, row, column) => {
+  const popperOptions = {
+    strategy: "fixed",
+    ...props.popperOptions
+  };
+  const tooltipFormatterContent = isFunction(column == null ? void 0 : column.tooltipFormatter) ? column.tooltipFormatter({
+    row,
+    column,
+    cellValue: getProp(row, column.property).value
+  }) : void 0;
+  if (isVNode(tooltipFormatterContent)) {
+    return {
+      slotContent: tooltipFormatterContent,
+      content: null,
+      ...props,
+      popperOptions
+    };
+  }
+  return {
+    slotContent: null,
+    content: tooltipFormatterContent != null ? tooltipFormatterContent : innerText,
+    ...props,
+    popperOptions
+  };
+};
+let removePopper = null;
+function createTablePopper(props, popperContent, row, column, trigger, table) {
+  var _a;
+  const tableOverflowTooltipProps = getTableOverflowTooltipProps(props, popperContent, row, column);
+  const mergedProps = {
+    ...tableOverflowTooltipProps,
+    slotContent: void 0
+  };
+  if ((removePopper == null ? void 0 : removePopper.trigger) === trigger) {
+    const comp = (_a = removePopper.vm) == null ? void 0 : _a.component;
+    merge(comp == null ? void 0 : comp.props, mergedProps);
+    if (comp && tableOverflowTooltipProps.slotContent) {
+      comp.slots.content = () => [tableOverflowTooltipProps.slotContent];
+    }
+    return;
+  }
+  removePopper == null ? void 0 : removePopper();
+  const parentNode = table == null ? void 0 : table.refs.tableWrapper;
+  const ns = parentNode == null ? void 0 : parentNode.dataset.prefix;
+  const vm = createVNode(ElTooltip, {
+    virtualTriggering: true,
+    virtualRef: trigger,
+    appendTo: parentNode,
+    placement: "top",
+    transition: "none",
+    offset: 0,
+    hideAfter: 0,
+    ...mergedProps
+  }, tableOverflowTooltipProps.slotContent ? {
+    content: () => tableOverflowTooltipProps.slotContent
+  } : void 0);
+  vm.appContext = { ...table.appContext, ...table };
+  const container = document.createElement("div");
+  render(vm, container);
+  vm.component.exposed.onOpen();
+  const scrollContainer = parentNode == null ? void 0 : parentNode.querySelector(`.${ns}-scrollbar__wrap`);
+  removePopper = () => {
+    var _a2, _b;
+    if ((_b = (_a2 = vm.component) == null ? void 0 : _a2.exposed) == null ? void 0 : _b.onClose) {
+      vm.component.exposed.onClose();
+    }
+    render(null, container);
+    const currentRemovePopper = removePopper;
+    scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", currentRemovePopper);
+    currentRemovePopper.trigger = void 0;
+    currentRemovePopper.vm = void 0;
+    removePopper = null;
+  };
+  removePopper.trigger = trigger != null ? trigger : void 0;
+  removePopper.vm = vm;
+  scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", removePopper);
+}
+function getCurrentColumns(column) {
+  if (column.children) {
+    return flatMap(column.children, getCurrentColumns);
+  } else {
+    return [column];
+  }
+}
+function getColSpan(colSpan, column) {
+  return colSpan + column.colSpan;
+}
+const isFixedColumn = (index, fixed, store, realColumns) => {
+  let start = 0;
+  let after = index;
+  const columns = store.states.columns.value;
+  if (realColumns) {
+    const curColumns = getCurrentColumns(realColumns[index]);
+    const preColumns = columns.slice(0, columns.indexOf(curColumns[0]));
+    start = preColumns.reduce(getColSpan, 0);
+    after = start + curColumns.reduce(getColSpan, 0) - 1;
+  } else {
+    start = index;
+  }
+  let fixedLayout;
+  switch (fixed) {
+    case "left":
+      if (after < store.states.fixedLeafColumnsLength.value) {
+        fixedLayout = "left";
+      }
+      break;
+    case "right":
+      if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
+        fixedLayout = "right";
+      }
+      break;
+    default:
+      if (after < store.states.fixedLeafColumnsLength.value) {
+        fixedLayout = "left";
+      } else if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
+        fixedLayout = "right";
+      }
+  }
+  return fixedLayout ? {
+    direction: fixedLayout,
+    start,
+    after
+  } : {};
+};
+const getFixedColumnsClass = (namespace, index, fixed, store, realColumns, offset = 0) => {
+  const classes = [];
+  const { direction, start, after } = isFixedColumn(index, fixed, store, realColumns);
+  if (direction) {
+    const isLeft = direction === "left";
+    classes.push(`${namespace}-fixed-column--${direction}`);
+    if (isLeft && after + offset === store.states.fixedLeafColumnsLength.value - 1) {
+      classes.push("is-last-column");
+    } else if (!isLeft && start - offset === store.states.columns.value.length - store.states.rightFixedLeafColumnsLength.value) {
+      classes.push("is-first-column");
+    }
+  }
+  return classes;
+};
+function getOffset(offset, column) {
+  return offset + (isNull(column.realWidth) || Number.isNaN(column.realWidth) ? Number(column.width) : column.realWidth);
+}
+const getFixedColumnOffset = (index, fixed, store, realColumns) => {
+  const {
+    direction,
+    start = 0,
+    after = 0
+  } = isFixedColumn(index, fixed, store, realColumns);
+  if (!direction) {
+    return;
+  }
+  const styles = {};
+  const isLeft = direction === "left";
+  const columns = store.states.columns.value;
+  if (isLeft) {
+    styles.left = columns.slice(0, start).reduce(getOffset, 0);
+  } else {
+    styles.right = columns.slice(after + 1).reverse().reduce(getOffset, 0);
+  }
+  return styles;
+};
+const ensurePosition = (style, key) => {
+  if (!style)
+    return;
+  if (!Number.isNaN(style[key])) {
+    style[key] = `${style[key]}px`;
+  }
+};
+
+export { compose, createTablePopper, ensurePosition, getCell, getColumnByCell, getColumnById, getColumnByKey, getFixedColumnOffset, getFixedColumnsClass, getKeysMap, getRowIdentity, isFixedColumn, mergeOptions, orderBy, parseHeight, parseMinWidth, parseWidth, removePopper, toggleRowStatus, walkTreeNode };
+//# sourceMappingURL=util.mjs.map