@varlet/ui 3.17.1 → 3.18.0-alpha.1781192892883

package/es/data-table/useBodyRows.mjs

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { computed } from "vue";
+import { createCellSpanMatrix, resolveSpan } from "./span.mjs";
+function useBodyRows({
+  columns,
+  sourceRows,
+  tree,
+  collapsedTreeRowKeys,
+  expandedRowKeySet,
+  firstTreeColumnIndex,
+  getRowKey,
+  getTreeChildren
+}) {
+  const allFlatRows = computed(() => {
+    return tree() ? buildTreeFlatRows(sourceRows(), true) : buildRows(sourceRows());
+  });
+  const visibleFlatRows = computed(() => {
+    return tree() ? buildTreeFlatRows(sourceRows(), false) : allFlatRows.value;
+  });
+  const treeRowMeta = computed(() => {
+    const rowByKey = /* @__PURE__ */ new Map();
+    const rowByObject = /* @__PURE__ */ new Map();
+    const parentKeyByChild = /* @__PURE__ */ new Map();
+    for (const flatRow of allFlatRows.value) {
+      rowByKey.set(flatRow.key, flatRow);
+      rowByObject.set(flatRow.row, flatRow);
+      if (flatRow.parentKey != null) {
+        parentKeyByChild.set(flatRow.key, flatRow.parentKey);
+      }
+    }
+    return {
+      rowByKey,
+      rowByObject,
+      parentKeyByChild
+    };
+  });
+  const bodyRows = computed(() => {
+    const resolvedColumns = columns();
+    const rowCount = visibleFlatRows.value.length;
+    const columnCount = resolvedColumns.length;
+    const matrix = createCellSpanMatrix(rowCount, columnCount);
+    return visibleFlatRows.value.map((flatRow, visibleRowIndex) => {
+      const cells = [];
+      resolvedColumns.forEach((column, columnIndex) => {
+        var _a, _b;
+        if (matrix.isCovered(visibleRowIndex, columnIndex)) {
+          return;
+        }
+        const context = { row: flatRow.row, rowIndex: flatRow.rowIndex, column };
+        const maxColSpan = columnCount - columnIndex;
+        const maxRowSpan = rowCount - visibleRowIndex;
+        const colSpan = resolveSpan(column.colSpan, maxColSpan, context);
+        const rowSpan = resolveSpan(column.rowSpan, maxRowSpan, context);
+        if (colSpan === 0 || rowSpan === 0) {
+          return;
+        }
+        matrix.cover(visibleRowIndex, columnIndex, rowSpan, colSpan);
+        const isTreeColumn = columnIndex === firstTreeColumnIndex.value;
+        cells.push({
+          key: `${(_b = (_a = column.key) != null ? _a : column.type) != null ? _b : columnIndex}-${visibleRowIndex}-${columnIndex}`,
+          columnIndex,
+          column,
+          treeLevel: isTreeColumn ? flatRow.level : void 0,
+          treeExpandable: isTreeColumn ? flatRow.expandable : void 0,
+          treeExpanded: isTreeColumn ? flatRow.treeExpanded : void 0,
+          colSpan: colSpan > 1 ? colSpan : void 0,
+          rowSpan: rowSpan > 1 ? rowSpan : void 0
+        });
+      });
+      return __spreadProps(__spreadValues({}, flatRow), {
+        expanded: expandedRowKeySet.value.has(flatRow.key),
+        cells
+      });
+    });
+  });
+  function buildRows(sourceRows2) {
+    return sourceRows2.map((row, rowIndex) => ({
+      key: getRowKey(row, rowIndex),
+      row,
+      rowIndex,
+      level: 0,
+      expandable: false,
+      treeExpanded: true
+    }));
+  }
+  function buildTreeFlatRows(sourceRows2, includeCollapsedChildren) {
+    const rows = [];
+    let rowIndex = 0;
+    function visit(source, level, parentKey, visible) {
+      for (const row of source) {
+        const currentRowIndex = rowIndex;
+        rowIndex += 1;
+        const key = getRowKey(row, currentRowIndex);
+        const children = getTreeChildren(row);
+        const expandable = tree() && children.length > 0;
+        const treeExpanded = !expandable || !collapsedTreeRowKeys.value.has(key);
+        if (includeCollapsedChildren || visible) {
+          rows.push({
+            key,
+            row,
+            rowIndex: currentRowIndex,
+            level,
+            parentKey,
+            expandable,
+            treeExpanded
+          });
+        }
+        visit(children, level + 1, key, visible && treeExpanded);
+      }
+    }
+    visit(sourceRows2, 0, void 0, true);
+    return rows;
+  }
+  return {
+    allFlatRows,
+    visibleFlatRows,
+    treeRowMeta,
+    bodyRows
+  };
+}
+export {
+  useBodyRows
+};

package/es/data-table/useColumnSizes.mjs

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { clamp } from "@varlet/shared";
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+import { toPxNum, toSizeUnit } from "../utils/elements.mjs";
+const defaultDataTableControlColumnWidth = 52;
+function useColumnSizes({ columns, isSelectionColumn, isExpandColumn }) {
+  const resizedColumnWidths = ref({});
+  let stopActiveResize;
+  const resolvedColumnWidths = computed(() => {
+    return columns().map((column, columnIndex) => {
+      var _a;
+      return (_a = getResolvedColumnWidth(column, columnIndex)) != null ? _a : 0;
+    });
+  });
+  const hasResolvedColumnWidth = computed(() => {
+    return columns().some((column, columnIndex) => {
+      return getResolvedColumnWidth(column, columnIndex) != null;
+    });
+  });
+  const totalResolvedColumnWidth = computed(() => {
+    return resolvedColumnWidths.value.reduce((total, width) => total + width, 0);
+  });
+  watch(
+    columns,
+    () => {
+      const activeColumnIds = new Set(columns().map((column, columnIndex) => getColumnId(column, columnIndex)));
+      const nextWidths = {};
+      Object.entries(resizedColumnWidths.value).forEach(([columnId, width]) => {
+        if (activeColumnIds.has(columnId)) {
+          nextWidths[columnId] = width;
+        }
+      });
+      resizedColumnWidths.value = nextWidths;
+    },
+    { immediate: true }
+  );
+  onBeforeUnmount(() => {
+    stopActiveResize == null ? void 0 : stopActiveResize();
+  });
+  function isColumnResizable(column) {
+    return column.resizable === true;
+  }
+  function getColStyle(column, columnIndex) {
+    const style = {};
+    const resizedWidth = getResizedColumnWidth(column, columnIndex);
+    if (resizedWidth != null) {
+      style.width = toSizeUnit(resizedWidth);
+      style.minWidth = toSizeUnit(resizedWidth);
+      style.maxWidth = toSizeUnit(resizedWidth);
+      return style;
+    }
+    const resolvedWidth = getResolvedColumnWidth(column, columnIndex);
+    if (resolvedWidth != null) {
+      style.width = toSizeUnit(resolvedWidth);
+    }
+    const minWidth = getColumnMinWidth(column);
+    if (minWidth != null) {
+      style.minWidth = toSizeUnit(minWidth);
+    } else if (resolvedWidth != null) {
+      style.minWidth = toSizeUnit(resolvedWidth);
+    }
+    const maxWidth = getColumnMaxWidth(column);
+    if (maxWidth != null) {
+      style.maxWidth = toSizeUnit(maxWidth);
+    }
+    return style;
+  }
+  function startColumnResize(event, headerCell) {
+    var _a;
+    if (!isColumnResizable(headerCell.column)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    const headerCellElement = (_a = event.currentTarget) == null ? void 0 : _a.closest("th");
+    if (!headerCellElement) {
+      return;
+    }
+    stopActiveResize == null ? void 0 : stopActiveResize();
+    const startX = event.clientX;
+    const startWidth = headerCellElement.getBoundingClientRect().width;
+    const columnId = getColumnId(headerCell.column, headerCell.startLeafColumnIndex);
+    document.addEventListener("mousemove", handlePointerMove);
+    document.addEventListener("mouseup", handlePointerUp);
+    stopActiveResize = detach;
+    function handlePointerMove(event2) {
+      const nextWidth = getLimitedColumnWidth(headerCell.column, startWidth + event2.clientX - startX);
+      resizedColumnWidths.value = __spreadProps(__spreadValues({}, resizedColumnWidths.value), {
+        [columnId]: nextWidth
+      });
+    }
+    function handlePointerUp() {
+      detach();
+    }
+    function detach() {
+      document.removeEventListener("mousemove", handlePointerMove);
+      document.removeEventListener("mouseup", handlePointerUp);
+      stopActiveResize = void 0;
+    }
+  }
+  function getResizedColumnWidth(column, columnIndex) {
+    return resizedColumnWidths.value[getColumnId(column, columnIndex)];
+  }
+  function getResolvedColumnWidth(column, columnIndex) {
+    var _a;
+    const resizedWidth = getResizedColumnWidth(column, columnIndex);
+    if (resizedWidth != null) {
+      return resizedWidth;
+    }
+    const preferredWidth = (_a = column.width) != null ? _a : isSelectionColumn(column) || isExpandColumn(column) ? defaultDataTableControlColumnWidth : void 0;
+    if (preferredWidth != null) {
+      return getLimitedColumnWidth(column, toPxNum(preferredWidth));
+    }
+    const minWidth = getColumnMinWidth(column);
+    if (minWidth != null) {
+      return minWidth;
+    }
+  }
+  function getColumnId(column, columnIndex) {
+    var _a, _b;
+    return `${(_b = (_a = column.key) != null ? _a : column.type) != null ? _b : "column"}-${columnIndex}`;
+  }
+  function getColumnMinWidth(column) {
+    if (column.minWidth == null) {
+      return;
+    }
+    const minWidth = toPxNum(column.minWidth);
+    const maxWidth = getColumnMaxWidth(column);
+    if (maxWidth == null) {
+      return minWidth;
+    }
+    return Math.min(minWidth, maxWidth);
+  }
+  function getColumnMaxWidth(column) {
+    if (column.maxWidth == null) {
+      return;
+    }
+    return toPxNum(column.maxWidth);
+  }
+  function getLimitedColumnWidth(column, width) {
+    var _a, _b;
+    const minWidth = (_a = getColumnMinWidth(column)) != null ? _a : 0;
+    const maxWidth = (_b = getColumnMaxWidth(column)) != null ? _b : Number.POSITIVE_INFINITY;
+    return clamp(width, minWidth, maxWidth);
+  }
+  return {
+    hasResolvedColumnWidth,
+    resolvedColumnWidths,
+    totalResolvedColumnWidth,
+    getColStyle,
+    isColumnResizable,
+    startColumnResize
+  };
+}
+export {
+  useColumnSizes
+};

package/es/data-table/useColumnsFixedOffsets.mjs

@@ -0,0 +1,90 @@
+import { computed } from "vue";
+function useColumnsFixedOffsets({ columns, resolvedColumnWidths }) {
+  const lastLeftFixedColumnIndex = computed(() => {
+    return findEdgeFixedColumnIndex("left");
+  });
+  const firstRightFixedColumnIndex = computed(() => {
+    return findEdgeFixedColumnIndex("right");
+  });
+  const leftFixedOffsets = computed(() => {
+    return buildFixedOffsets("left");
+  });
+  const rightFixedOffsets = computed(() => {
+    return buildFixedOffsets("right");
+  });
+  function getFixedStyle(fixed, columnIndex) {
+    var _a, _b;
+    if (fixed === "left") {
+      return {
+        left: `${(_a = leftFixedOffsets.value[columnIndex]) != null ? _a : 0}px`,
+        position: "sticky",
+        zIndex: 2
+      };
+    }
+    if (fixed === "right") {
+      return {
+        right: `${(_b = rightFixedOffsets.value[columnIndex]) != null ? _b : 0}px`,
+        position: "sticky",
+        zIndex: 2
+      };
+    }
+    return {};
+  }
+  function buildFixedOffsets(direction) {
+    const resolvedColumns = columns();
+    const widths = resolvedColumnWidths();
+    const offsets = Array(resolvedColumns.length).fill(void 0);
+    let offset = 0;
+    if (direction === "left") {
+      for (let index = 0; index < resolvedColumns.length; index += 1) {
+        if (resolvedColumns[index].fixed !== "left") {
+          continue;
+        }
+        offsets[index] = offset;
+        offset += widths[index];
+      }
+      return offsets;
+    }
+    for (let index = resolvedColumns.length - 1; index >= 0; index -= 1) {
+      if (resolvedColumns[index].fixed !== "right") {
+        continue;
+      }
+      offsets[index] = offset;
+      offset += widths[index];
+    }
+    return offsets;
+  }
+  function isLastLeftFixedColumn(columnIndex) {
+    return lastLeftFixedColumnIndex.value === columnIndex;
+  }
+  function isFirstRightFixedColumn(columnIndex) {
+    return firstRightFixedColumnIndex.value === columnIndex;
+  }
+  function findEdgeFixedColumnIndex(direction) {
+    const resolvedColumns = columns();
+    if (direction === "left") {
+      for (let index = resolvedColumns.length - 1; index >= 0; index -= 1) {
+        if (resolvedColumns[index].fixed === "left") {
+          return index;
+        }
+      }
+      return -1;
+    }
+    for (let index = 0; index < resolvedColumns.length; index += 1) {
+      if (resolvedColumns[index].fixed === "right") {
+        return index;
+      }
+    }
+    return -1;
+  }
+  return {
+    getFixedStyle,
+    isFirstRightFixedColumn,
+    isLastLeftFixedColumn,
+    leftFixedOffsets,
+    rightFixedOffsets
+  };
+}
+export {
+  useColumnsFixedOffsets
+};

package/es/data-table/useContainerScroll.mjs

@@ -0,0 +1,35 @@
+import { onWindowResize, useResizeObserver } from "@varlet/use";
+import { nextTick, ref, watch } from "vue";
+function useContainerScroll(sources = []) {
+  const container = ref();
+  const scrollLeft = ref(0);
+  const maxScrollDistance = ref(0);
+  watch(sources, syncContainerScrollAfterRender, { immediate: true, flush: "post" });
+  useResizeObserver(container, syncContainerScrollAfterRender);
+  onWindowResize(syncContainerScrollAfterRender);
+  function syncContainerScrollAfterRender() {
+    nextTick(syncContainerScroll);
+  }
+  function syncContainerScroll() {
+    if (container.value) {
+      updateContainerScrollState(container.value);
+    }
+  }
+  function updateContainerScrollState(element) {
+    scrollLeft.value = element.scrollLeft;
+    maxScrollDistance.value = Math.max(element.scrollWidth - element.clientWidth, 0);
+  }
+  function handleContainerScroll(event) {
+    updateContainerScrollState(event.currentTarget);
+  }
+  return {
+    container,
+    scrollLeft,
+    maxScrollDistance,
+    handleContainerScroll,
+    syncContainerScroll
+  };
+}
+export {
+  useContainerScroll
+};

package/es/data-table/useExpandRow.mjs

@@ -0,0 +1,46 @@
+import { computed } from "vue";
+function useExpandRow({ columns, expandedRowKeys, isExpandColumn }) {
+  const expandedRowKeySet = computed(() => new Set(expandedRowKeys.value));
+  const expandColumn = computed(() => columns().find(isExpandColumn));
+  function isRowExpandable(bodyRow, column) {
+    if (!(column == null ? void 0 : column.expandable)) {
+      return true;
+    }
+    return column.expandable({
+      row: bodyRow.row,
+      rowIndex: bodyRow.rowIndex
+    });
+  }
+  function toggleRowExpanded(bodyRow) {
+    const column = expandColumn.value;
+    if (!column || !isRowExpandable(bodyRow, column)) {
+      return;
+    }
+    const target = new Set(expandedRowKeys.value);
+    if (target.has(bodyRow.key)) {
+      target.delete(bodyRow.key);
+    } else {
+      target.add(bodyRow.key);
+    }
+    expandedRowKeys.value = [...target];
+  }
+  function renderExpandedRow(bodyRow) {
+    const column = expandColumn.value;
+    if (!column) {
+      return;
+    }
+    return column.renderExpand({
+      row: bodyRow.row,
+      rowIndex: bodyRow.rowIndex
+    });
+  }
+  return {
+    expandedRowKeySet,
+    isRowExpandable,
+    toggleRowExpanded,
+    renderExpandedRow
+  };
+}
+export {
+  useExpandRow
+};

package/es/data-table/useFootRows.mjs

@@ -0,0 +1,49 @@
+import { normalizeToArray } from "@varlet/shared";
+import { computed } from "vue";
+import { createCellSpanMatrix, resolveSpan } from "./span.mjs";
+function useFootRows({ columns, sourceRows, summary }) {
+  const footRows = computed(() => {
+    const summaryGetter = summary();
+    if (!summaryGetter) {
+      return [];
+    }
+    const summaryResult = summaryGetter({ data: sourceRows() });
+    const summaryRecords = normalizeToArray(summaryResult);
+    const resolvedColumns = columns();
+    const matrix = createCellSpanMatrix(summaryRecords.length, resolvedColumns.length);
+    return summaryRecords.map(
+      (summaryRecord, rowIndex) => resolvedColumns.flatMap((column, columnIndex) => {
+        var _a, _b;
+        if (matrix.isCovered(rowIndex, columnIndex)) {
+          return [];
+        }
+        const key = (_b = (_a = column.key) != null ? _a : column.type) != null ? _b : String(columnIndex);
+        const summaryCell = summaryRecord[key];
+        const maxColSpan = resolvedColumns.length - columnIndex;
+        const maxRowSpan = summaryRecords.length - rowIndex;
+        const colSpan = resolveSpan(summaryCell == null ? void 0 : summaryCell.colSpan, maxColSpan);
+        const rowSpan = resolveSpan(summaryCell == null ? void 0 : summaryCell.rowSpan, maxRowSpan);
+        if (colSpan === 0 || rowSpan === 0) {
+          return [];
+        }
+        matrix.cover(rowIndex, columnIndex, rowSpan, colSpan);
+        return [
+          {
+            key: `${rowIndex}-${key}`,
+            columnIndex,
+            column,
+            value: summaryCell == null ? void 0 : summaryCell.value,
+            colSpan: colSpan > 1 ? colSpan : void 0,
+            rowSpan: rowSpan > 1 ? rowSpan : void 0
+          }
+        ];
+      })
+    );
+  });
+  return {
+    footRows
+  };
+}
+export {
+  useFootRows
+};

package/es/data-table/useHeaderRows.mjs

@@ -0,0 +1,113 @@
+import { isArray } from "@varlet/shared";
+import { computed } from "vue";
+import { resolveSpan } from "./span.mjs";
+function useHeaderRows({ columns }) {
+  const normalizedColumns = computed(() => flattenLeafColumns(columns()));
+  const headerRows = computed(() => {
+    const rawColumns = columns();
+    const rows = [];
+    const maxDepth = getColumnsMaxDepth(rawColumns);
+    let nextLeafColumnIndex = 0;
+    buildHeaderRows(rawColumns, 0);
+    function buildHeaderRows(columns2, rowIndex) {
+      if (!rows[rowIndex]) {
+        rows[rowIndex] = [];
+      }
+      const headerRow = rows[rowIndex];
+      const leafRangeStart = nextLeafColumnIndex;
+      const leafRangeEnd = leafRangeStart + flattenLeafColumns(columns2).length - 1;
+      let coveredUntilLeafColumnIndex = leafRangeStart;
+      let visibleLeafColSpan = 0;
+      columns2.forEach((column, columnIndex) => {
+        if (isGroupColumn(column)) {
+          visibleLeafColSpan += buildGroupHeaderCell(headerRow, column, rowIndex, columnIndex);
+          return;
+        }
+        const colSpan = buildLeafHeaderCell(headerRow, column, rowIndex, leafRangeEnd, coveredUntilLeafColumnIndex);
+        if (colSpan > 1) {
+          coveredUntilLeafColumnIndex = nextLeafColumnIndex - 1 + colSpan;
+        }
+        visibleLeafColSpan += colSpan;
+      });
+      return visibleLeafColSpan;
+    }
+    function buildGroupHeaderCell(headerRow, column, rowIndex, columnIndex) {
+      const startLeafColumnIndex = nextLeafColumnIndex;
+      const colSpan = buildHeaderRows(column.children, rowIndex + 1);
+      const endLeafColumnIndex = nextLeafColumnIndex - 1;
+      if (colSpan === 0) {
+        return 0;
+      }
+      headerRow.push({
+        key: getHeaderCellKey(column, rowIndex, columnIndex),
+        column,
+        colSpan,
+        startLeafColumnIndex,
+        endLeafColumnIndex,
+        fixed: resolveHeaderCellFixed(normalizedColumns.value.slice(startLeafColumnIndex, endLeafColumnIndex + 1))
+      });
+      return colSpan;
+    }
+    function buildLeafHeaderCell(headerRow, column, rowIndex, leafRangeEnd, coveredUntilLeafColumnIndex) {
+      if (nextLeafColumnIndex < coveredUntilLeafColumnIndex) {
+        nextLeafColumnIndex += 1;
+        return 0;
+      }
+      const startLeafColumnIndex = nextLeafColumnIndex;
+      const maxColSpan = leafRangeEnd - startLeafColumnIndex + 1;
+      const colSpan = resolveSpan(column.titleColSpan, maxColSpan);
+      nextLeafColumnIndex += 1;
+      if (colSpan === 0) {
+        return 0;
+      }
+      headerRow.push({
+        key: getHeaderCellKey(column, rowIndex, startLeafColumnIndex),
+        column,
+        colSpan: colSpan > 1 ? colSpan : void 0,
+        rowSpan: maxDepth - rowIndex > 1 ? maxDepth - rowIndex : void 0,
+        startLeafColumnIndex,
+        endLeafColumnIndex: startLeafColumnIndex + colSpan - 1,
+        fixed: resolveHeaderCellFixed(
+          normalizedColumns.value.slice(startLeafColumnIndex, startLeafColumnIndex + colSpan)
+        )
+      });
+      return colSpan;
+    }
+    return rows;
+  });
+  function isGroupColumn(column) {
+    return "children" in column && isArray(column.children) && column.children.length > 0;
+  }
+  function flattenLeafColumns(columns2) {
+    return columns2.flatMap((column) => isGroupColumn(column) ? flattenLeafColumns(column.children) : [column]);
+  }
+  function getHeaderCellKey(column, depth, columnIndex) {
+    var _a, _b;
+    return `${(_b = (_a = column.key) != null ? _a : column.type) != null ? _b : "group"}-header-${depth}-${columnIndex}`;
+  }
+  function getColumnsMaxDepth(columns2) {
+    if (!columns2.length) {
+      return 0;
+    }
+    return Math.max(...columns2.map((column) => isGroupColumn(column) ? 1 + getColumnsMaxDepth(column.children) : 1));
+  }
+  function resolveHeaderCellFixed(columns2) {
+    if (!columns2.length) {
+      return;
+    }
+    if (columns2.every((column) => column.fixed === "left")) {
+      return "left";
+    }
+    if (columns2.every((column) => column.fixed === "right")) {
+      return "right";
+    }
+  }
+  return {
+    normalizedColumns,
+    headerRows,
+    isGroupColumn
+  };
+}
+export {
+  useHeaderRows
+};