@vuu-ui/vuu-utils 0.13.8 → 0.13.10

package/esm/packages/vuu-utils/src/column-utils.js

@@ -0,0 +1,815 @@
+import { moveItem } from './array-utils.js';
+
+const SORT_ASC = "asc";
+const NO_HEADINGS = [];
+const DEFAULT_COL_WIDTH = 100;
+const DEFAULT_MAX_WIDTH = 250;
+const DEFAULT_MIN_WIDTH = 50;
+const AggregationType = {
+  Average: 2,
+  Count: 3,
+  Distinct: 6,
+  Sum: 1,
+  High: 4,
+  Low: 5
+};
+function mapSortCriteria(sortCriteria, columnMap, metadataOffset = 0) {
+  return sortCriteria.map((s) => {
+    if (typeof s === "string") {
+      return [columnMap[s] + metadataOffset, "asc"];
+    } else if (Array.isArray(s)) {
+      const [columnName, sortDir] = s;
+      return [columnMap[columnName] + metadataOffset, sortDir || SORT_ASC];
+    } else {
+      throw Error("columnUtils.mapSortCriteria invalid input");
+    }
+  });
+}
+const numericTypes = ["int", "long", "double"];
+const getDefaultAlignment = (serverDataType) => serverDataType === void 0 ? "left" : numericTypes.includes(serverDataType) ? "right" : "left";
+const getRuntimeColumnWidth = (col, runtimeColumns) => {
+  const runtimeColumn = runtimeColumns.find(({ name }) => name === col.name);
+  if (runtimeColumn) {
+    return runtimeColumn.width;
+  } else {
+    return DEFAULT_COL_WIDTH;
+  }
+};
+const applyRuntimeColumnWidthsToConfig = (tableConfig, columns) => {
+  return {
+    ...tableConfig,
+    columns: columns.map((column) => ({
+      ...column,
+      width: column.width ?? getRuntimeColumnWidth(column, columns)
+    })),
+    columnLayout: "manual"
+  };
+};
+const isValidColumnAlignment = (v) => v === "left" || v === "right";
+const isValidPinLocation = (v) => isValidColumnAlignment(v) || v === "floating" || v === "";
+const VUU_COLUMN_DATA_TYPES = [
+  "long",
+  "double",
+  "int",
+  "string",
+  "char",
+  "boolean"
+];
+const isVuuColumnDataType = (value) => VUU_COLUMN_DATA_TYPES.includes(value);
+const fromServerDataType = (serverDataType) => {
+  switch (serverDataType) {
+    case "double":
+    case "int":
+    case "long":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+const isNumericColumn = ({ serverDataType, type }) => {
+  if (serverDataType === "int" || serverDataType === "long" || serverDataType === "double") {
+    return true;
+  }
+  if (typeof type === "string") {
+    return type === "number";
+  }
+  if (typeof type?.name === "string") {
+    return type?.name === "number";
+  }
+  return false;
+};
+const isDateTimeDataValue = (column) => (isTypeDescriptor(column.type) ? column.type.name : column.type) === "date/time";
+const isPinned = (column) => typeof column.pin === "string";
+const hasHeadings = (column) => Array.isArray(column.heading) && column.heading.length > 0;
+const isResizing = (column) => column.resizing;
+const isTextColumn = ({ serverDataType }) => serverDataType === void 0 ? false : serverDataType === "char" || serverDataType === "string";
+const toColumnDescriptor = (name) => ({
+  name
+});
+const isTypeDescriptor = (type) => typeof type !== "undefined" && typeof type !== "string";
+const EMPTY_COLUMN_MAP = {};
+const isColumnTypeRenderer = (renderer) => typeof renderer?.name !== "undefined";
+const hasCustomRenderer = (type) => isTypeDescriptor(type) && isColumnTypeRenderer(type.renderer);
+const isLookupRenderer = (renderer) => typeof renderer?.name !== "undefined" && "lookup" in renderer;
+const isValueListRenderer = (renderer) => typeof renderer?.name !== "undefined" && Array.isArray(renderer.values);
+const hasValidationRules = (type) => isTypeDescriptor(type) && Array.isArray(type.rules) && type.rules.length > 0;
+const isMappedValueTypeRenderer = (renderer) => renderer !== void 0 && typeof renderer?.map !== "undefined";
+function buildColumnMap(columns) {
+  const start = metadataKeys.count;
+  if (columns) {
+    return columns.reduce((map, column, i) => {
+      if (typeof column === "string") {
+        map[column] = start + i;
+      } else {
+        map[column.name] = start + i;
+      }
+      return map;
+    }, {});
+  } else {
+    return EMPTY_COLUMN_MAP;
+  }
+}
+function projectUpdates(updates) {
+  const results = [];
+  const metadataOffset = metadataKeys.count - 2;
+  for (let i = 0; i < updates.length; i += 3) {
+    results[i] = updates[i] + metadataOffset;
+    results[i + 1] = updates[i + 1];
+    results[i + 2] = updates[i + 2];
+  }
+  return results;
+}
+const KEY = 6;
+const metadataKeys = {
+  IDX: 0,
+  RENDER_IDX: 1,
+  IS_LEAF: 2,
+  IS_EXPANDED: 3,
+  DEPTH: 4,
+  COUNT: 5,
+  KEY,
+  SELECTED: 7,
+  count: 8,
+  // TODO following only used in datamodel
+  PARENT_IDX: "parent_idx",
+  IDX_POINTER: "idx_pointer",
+  FILTER_COUNT: "filter_count",
+  NEXT_FILTER_IDX: "next_filter_idx"
+};
+const insertColumn = (columns, column) => {
+  const { originalIdx } = column;
+  if (typeof originalIdx === "number") {
+    for (let i = 0; i < columns.length; i++) {
+      const { originalIdx: colIdx = -1 } = columns[i];
+      if (colIdx > originalIdx) {
+        columns.splice(i, 0, column);
+        return columns;
+      }
+    }
+  }
+  columns.push(column);
+  return columns;
+};
+const flattenColumnGroup = (columns) => {
+  if (columns[0]?.isGroup) {
+    const [groupColumn, ...nonGroupedColumns] = columns;
+    groupColumn.columns.forEach((groupColumn2) => {
+      insertColumn(nonGroupedColumns, groupColumn2);
+    });
+    return nonGroupedColumns;
+  } else {
+    return columns;
+  }
+};
+function extractGroupColumn({
+  availableWidth,
+  columns,
+  groupBy,
+  confirmed = true
+}) {
+  if (groupBy && groupBy.length > 0) {
+    const flattenedColumns = flattenColumnGroup(columns);
+    const [groupedColumns, rest] = flattenedColumns.reduce(
+      (result, column, i) => {
+        const [g, r] = result;
+        if (groupBy.includes(column.name)) {
+          g.push({
+            ...column,
+            originalIdx: i
+          });
+        } else {
+          r.push(column);
+        }
+        return result;
+      },
+      [[], []]
+    );
+    if (groupedColumns.length !== groupBy.length) {
+      throw Error(
+        `extractGroupColumn: no column definition found for all groupBy cols ${JSON.stringify(
+          groupBy
+        )} `
+      );
+    }
+    const groupOnly = rest.length === 0;
+    const groupCount = groupBy.length;
+    const groupCols = groupBy.map((name, idx) => {
+      const column = groupedColumns.find(
+        (col) => col.name === name
+      );
+      return {
+        ...column,
+        groupLevel: groupCount - idx
+      };
+    });
+    const width = groupOnly ? availableWidth : Math.min(
+      availableWidth,
+      groupCols.map((c) => c.width).reduce((a, b) => a + b) + 100
+    );
+    const groupCol = {
+      ariaColIndex: 1,
+      columns: groupCols,
+      heading: ["group-col"],
+      isGroup: true,
+      groupConfirmed: confirmed,
+      name: "group-col",
+      width
+    };
+    const withAdjustedAriaIndex = [];
+    let colIndex = 2;
+    for (const column of rest) {
+      withAdjustedAriaIndex.push({
+        ...column,
+        ariaColIndex: column.hidden ? -1 : colIndex
+      });
+      if (!column.hidden) {
+        colIndex += 1;
+      }
+    }
+    return [groupCol, withAdjustedAriaIndex];
+  }
+  return [null, flattenColumnGroup(columns)];
+}
+const isGroupColumn = (column) => column.isGroup === true;
+const checkConfirmationPending = (previousConfig) => {
+  if (previousConfig) {
+    const [column] = previousConfig.columns;
+    if (isGroupColumn(column)) {
+      return column.groupConfirmed;
+    }
+  }
+};
+const isJsonAttribute = (value) => typeof value === "string" && (value.endsWith("{") || value.endsWith("["));
+const isJsonGroup = (column, row, columnMap) => column.type?.name === "json" && isJsonAttribute(row[columnMap[column.name]]);
+const isJsonColumn = (column) => column.type?.name === "json";
+const sortPinnedColumns = (columns) => {
+  const leftPinnedColumns = [];
+  const rightPinnedColumns = [];
+  const restColumns = [];
+  let pinnedWidthLeft = 4;
+  for (const column of columns) {
+    switch (column.pin) {
+      case "left":
+        {
+          leftPinnedColumns.push({
+            ...column,
+            endPin: void 0,
+            pinnedOffset: pinnedWidthLeft
+          });
+          pinnedWidthLeft += column.width;
+        }
+        break;
+      // store right pinned columns initially in reverse order
+      case "right":
+        rightPinnedColumns.unshift(column);
+        break;
+      default:
+        restColumns.push(column);
+    }
+  }
+  if (leftPinnedColumns.length) {
+    leftPinnedColumns.push({
+      ...leftPinnedColumns.pop(),
+      endPin: true
+    });
+  }
+  const allColumns = leftPinnedColumns.length ? leftPinnedColumns.concat(restColumns) : restColumns;
+  if (rightPinnedColumns.length) {
+    const measuredRightPinnedColumns = [];
+    let pinnedWidthRight = 0;
+    for (const column of rightPinnedColumns) {
+      measuredRightPinnedColumns.unshift({
+        ...column,
+        pinnedOffset: pinnedWidthRight
+      });
+      pinnedWidthRight += column.width;
+    }
+    measuredRightPinnedColumns[0].endPin = true;
+    return allColumns.concat(measuredRightPinnedColumns);
+  } else {
+    return allColumns;
+  }
+};
+const measurePinnedColumns = (columns, selectionEndSize) => {
+  let pinnedWidthLeft = 0;
+  let pinnedWidthRight = 0;
+  let unpinnedWidth = 0;
+  for (const column of columns) {
+    const { hidden, pin, width } = column;
+    const visibleWidth = hidden ? 0 : width;
+    if (pin === "left") {
+      pinnedWidthLeft += visibleWidth;
+    } else if (pin === "right") {
+      pinnedWidthRight += visibleWidth;
+    } else {
+      unpinnedWidth += visibleWidth;
+    }
+  }
+  return {
+    pinnedWidthLeft: pinnedWidthLeft + selectionEndSize,
+    pinnedWidthRight: pinnedWidthRight + selectionEndSize,
+    unpinnedWidth
+  };
+};
+const getTableHeadings = (columns) => {
+  if (columns.some(hasHeadings)) {
+    const maxHeadingDepth = columns.reduce(
+      (max, { heading: heading2 }) => Math.max(max, heading2?.length ?? 0),
+      0
+    );
+    let heading = void 0;
+    const tableHeadings = [];
+    let tableHeadingsRow;
+    for (let level = 0; level < maxHeadingDepth; level++) {
+      tableHeadingsRow = [];
+      columns.forEach(({ heading: columnHeading = NO_HEADINGS, width }) => {
+        const label = columnHeading[level] ?? "";
+        if (heading && heading.label === label) {
+          heading.width += width;
+        } else {
+          heading = { label, width };
+          tableHeadingsRow.push(heading);
+        }
+      });
+      tableHeadings.push(tableHeadingsRow);
+    }
+    return tableHeadings;
+  }
+  return NO_HEADINGS;
+};
+const getColumnStyle = ({
+  pin,
+  // the 4 is `selectionEndSize`, unfortunate if we need to be passed it from cell
+  // need to think about how to make this available
+  pinnedOffset = pin === "left" ? 0 : 4,
+  width
+}) => pin === "left" ? {
+  left: pinnedOffset,
+  width,
+  "--pin-width": `${pinnedOffset + width - 3}px`
+} : pin === "right" ? {
+  right: pinnedOffset,
+  width,
+  "--pin-width": `${pinnedOffset + width}px`
+} : { width };
+const setAggregations = (aggregations, column, aggType) => {
+  return aggregations.filter((agg) => agg.column !== column.name).concat({ column: column.name, aggType });
+};
+const applyGroupByToColumns = (props) => {
+  if (props.groupBy.length) {
+    const [groupColumn, nonGroupedColumns] = extractGroupColumn(props);
+    if (groupColumn) {
+      return [groupColumn].concat(nonGroupedColumns);
+    }
+  } else if (props.columns[0]?.isGroup) {
+    return flattenColumnGroup(props.columns);
+  }
+  return props.columns;
+};
+const applySortToColumns = (columns, sort) => columns.map((column) => {
+  const sorted = getSortType(column, sort);
+  if (sorted !== void 0) {
+    return {
+      ...column,
+      sorted
+    };
+  } else if (column.sorted) {
+    return {
+      ...column,
+      sorted: void 0
+    };
+  } else {
+    return column;
+  }
+});
+const removeSort = (columns) => columns.map((col) => col.sorted ? { ...col, sorted: void 0 } : col);
+const existingSort = (columns) => columns.some((col) => col.sorted);
+const getSortType = (column, { sortDefs }) => {
+  const sortDef = sortDefs.find((sortCol) => sortCol.column === column.name);
+  if (sortDef) {
+    return sortDefs.length > 1 ? (sortDefs.indexOf(sortDef) + 1) * (sortDef.sortType === "A" ? 1 : -1) : sortDef.sortType;
+  }
+};
+const getColumnName = (name) => {
+  const pos = name.indexOf(":");
+  if (pos === -1) {
+    return name;
+  } else {
+    return name.slice(0, pos);
+  }
+};
+const getColumnLabel = (column) => {
+  if (column.label) {
+    return column.label;
+  } else if (isCalculatedColumn(column.name)) {
+    const { name } = getCalculatedColumnDetails(column);
+    return name ?? column.name;
+  } else {
+    return column.name;
+  }
+};
+const findColumn = (columns, columnName) => {
+  const column = columns.find((col) => col.name === columnName);
+  if (column) {
+    return column;
+  } else {
+    const groupColumn = columns.find(
+      (col) => col.isGroup
+    );
+    if (groupColumn) {
+      return findColumn(groupColumn.columns, columnName);
+    }
+  }
+};
+function updateColumn(columns, column, options) {
+  const targetColumn = typeof column === "string" ? columns.find((col) => col.name === column) : column;
+  if (targetColumn) {
+    const replacementColumn = options ? { ...targetColumn, ...options } : targetColumn;
+    return columns.map(
+      (col) => col.name === replacementColumn.name ? replacementColumn : col
+    );
+  } else {
+    throw Error("column-utils.replaceColun, column not found");
+  }
+}
+const toDataSourceColumns = (column) => column.name;
+const dataSourceRowToDataRowDto = (row, columnMap) => {
+  return Object.entries(columnMap).reduce(
+    (map, [colName, key]) => {
+      map[colName] = row[key];
+      return map;
+    },
+    {}
+  );
+};
+const isDataLoading = (columns) => {
+  return isGroupColumn(columns[0]) && columns[0].groupConfirmed === false;
+};
+const getColumnsInViewport = (columns, vpStart, vpEnd) => {
+  const visibleColumns = [];
+  let preSpan = 0;
+  let rightPinnedOnly = false;
+  for (let columnOffset = 0, i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    if (column.hidden) {
+      continue;
+    } else if (rightPinnedOnly) {
+      if (column.pin === "right") {
+        visibleColumns.push(column);
+      }
+    } else if (columnOffset + column.width < vpStart) {
+      if (column.pin === "left") {
+        visibleColumns.push(column);
+      } else if (columnOffset + column.width + columns[i + 1]?.width > vpStart) {
+        visibleColumns.push(column);
+      } else {
+        preSpan += column.width;
+      }
+    } else if (columnOffset > vpEnd) {
+      rightPinnedOnly = true;
+    } else {
+      visibleColumns.push(column);
+    }
+    columnOffset += column.width;
+  }
+  return [visibleColumns, preSpan];
+};
+const isNotHidden = (column) => column.hidden !== true;
+const visibleColumnAtIndex = (columns, index) => {
+  if (columns.every(isNotHidden)) {
+    return columns[index];
+  } else {
+    return columns.filter(isNotHidden).at(index);
+  }
+};
+const { DEPTH, IS_LEAF } = metadataKeys;
+const getGroupIcon = (columns, row) => {
+  const { [DEPTH]: depth, [IS_LEAF]: isLeaf } = row;
+  if (isLeaf || depth > columns.length) {
+    return void 0;
+  } else if (depth === 0) {
+    return void 0;
+  } else {
+    const { getIcon } = columns[depth - 1];
+    return getIcon?.(row);
+  }
+};
+const getGroupValue = (columns, row, columnMap) => {
+  const { [DEPTH]: depth, [IS_LEAF]: isLeaf } = row;
+  if (isLeaf || depth > columns.length) {
+    return null;
+  } else if (depth === 0) {
+    return "$root";
+  } else {
+    const { name, valueFormatter } = columns[depth - 1];
+    const value = valueFormatter(row[columnMap[name]]);
+    return value;
+  }
+};
+const getDefaultColumnType = (serverDataType) => {
+  switch (serverDataType) {
+    case "int":
+    case "long":
+    case "double":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+const updateColumnFormatting = (column, formatting) => {
+  const { serverDataType, type = getDefaultColumnType(serverDataType) } = column;
+  if (isTypeDescriptor(type)) {
+    return { ...column, type: { ...type, formatting } };
+  } else {
+    return { ...column, type: { name: type, formatting } };
+  }
+};
+function updateColumnType(column, type) {
+  return isTypeDescriptor(column.type) ? { ...column, type: { ...column.type, name: type } } : { ...column, type };
+}
+const updateColumnRenderProps = (column, renderer) => {
+  const { serverDataType, type = getDefaultColumnType(serverDataType) } = column;
+  if (isTypeDescriptor(type)) {
+    return {
+      ...column,
+      type: {
+        ...type,
+        // TODO do we need to preserve any existing attributes from renderer ?
+        renderer
+      }
+    };
+  } else {
+    return { ...column, type: { name: type, renderer } };
+  }
+};
+const NO_TYPE_SETTINGS = {};
+const getTypeFormattingFromColumn = (column) => {
+  if (isTypeDescriptor(column.type)) {
+    return column.type.formatting ?? NO_TYPE_SETTINGS;
+  } else {
+    return NO_TYPE_SETTINGS;
+  }
+};
+const subscribedOnly = (columnNames) => (column) => column.source === "client" || columnNames?.includes(column.name);
+const addColumnToSubscribedColumns = (subscribedColumns, availableColumns, columnName) => {
+  const byColName = (n = columnName) => (column) => column.name === n;
+  if (subscribedColumns.findIndex(byColName()) !== -1) {
+    throw Error(
+      `column-utils, addColumnToSubscribedColumns column ${columnName} is already subscribed`
+    );
+  }
+  const indexOfAvailableColumn = availableColumns.findIndex(byColName());
+  if (indexOfAvailableColumn === -1) {
+    throw Error(
+      `column-utils, addColumnToSubscribedColumns column ${columnName} is not available`
+    );
+  }
+  const newColumn = {
+    ...availableColumns[indexOfAvailableColumn]
+  };
+  let index = -1;
+  for (let i = indexOfAvailableColumn - 1; i >= 0; i--) {
+    const { name } = availableColumns[i];
+    index = subscribedColumns.findIndex(byColName(name));
+    if (index !== -1) {
+      break;
+    }
+  }
+  if (index === -1) {
+    return [newColumn].concat(subscribedColumns);
+  } else {
+    const results = [];
+    for (let i = 0; i < subscribedColumns.length; i++) {
+      results.push(subscribedColumns[i]);
+      if (i === index) {
+        results.push(newColumn);
+        index = Number.MAX_SAFE_INTEGER;
+      }
+    }
+    return results;
+  }
+};
+const CalculatedColumnPattern = /.*:.*:.*/;
+const isCalculatedColumn = (columnName) => columnName !== void 0 && CalculatedColumnPattern.test(columnName);
+const getCalculatedColumnDetails = (column) => {
+  if (isCalculatedColumn(column.name)) {
+    const [name, serverDataType, expression] = column.name.split(/:=?/);
+    if (serverDataType && !isVuuColumnDataType(serverDataType)) {
+      throw Error(
+        `column-utils, getCalculatedColumnDetails ${serverDataType} is not valid type for column ${column.name}`
+      );
+    }
+    return {
+      name: name ?? "",
+      expression: expression ?? "",
+      serverDataType: isVuuColumnDataType(serverDataType) ? serverDataType : void 0
+    };
+  } else {
+    throw Error(`column.name is nor a calculated column`);
+  }
+};
+const setCalculatedColumnName = (column, name) => {
+  const [, type, expression] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${type}:${expression}`
+  };
+};
+const setCalculatedColumnType = (column, type) => {
+  const [name, , expression] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${type}:${expression}`
+  };
+};
+const setCalculatedColumnExpression = (column, expression) => {
+  const [name, type] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${type}:=${expression}`
+  };
+};
+const moveColumnTo = (columns, column, newIndex) => {
+  const index = columns.findIndex((col) => col.name === column.name);
+  return moveItem(columns, index, newIndex);
+};
+function replaceColumn(columns, column) {
+  return columns.map((col) => col.name === column.name ? column : col);
+}
+const applyDefaultColumnConfig = ({ columns, table }, getDefaultColumnConfig) => {
+  if (typeof getDefaultColumnConfig === "function") {
+    return columns.map((column) => {
+      const config = getDefaultColumnConfig(table.table, column.name);
+      if (config) {
+        return {
+          ...column,
+          ...config
+        };
+      } else {
+        return column;
+      }
+    });
+  } else {
+    return columns;
+  }
+};
+const measureColumns = (columns, defaultMaxWidth, defaultMinWidth) => columns.reduce(
+  (aggregated, column) => {
+    if (column.hidden !== true) {
+      aggregated.totalMinWidth += column.minWidth ?? defaultMinWidth;
+      aggregated.totalMaxWidth += column.maxWidth ?? defaultMaxWidth;
+      aggregated.totalWidth += column.width;
+      aggregated.flexCount += column.flex ?? 0;
+    }
+    return aggregated;
+  },
+  { totalMinWidth: 0, totalMaxWidth: 0, totalWidth: 0, flexCount: 0 }
+);
+function applyWidthToColumns(columns, {
+  availableWidth = 0,
+  columnLayout = "static",
+  defaultWidth = DEFAULT_COL_WIDTH,
+  defaultMinWidth = DEFAULT_MIN_WIDTH,
+  defaultMaxWidth = DEFAULT_MAX_WIDTH
+}) {
+  if (columnLayout === "fit") {
+    const { totalMinWidth, totalMaxWidth, totalWidth, flexCount } = measureColumns(columns, defaultMaxWidth, defaultMinWidth);
+    if (totalMaxWidth < availableWidth) {
+      return assignMaxWidthToAll(columns, defaultMaxWidth);
+    } else if (totalMinWidth > availableWidth) {
+      return columns;
+    } else if (totalWidth > availableWidth) {
+      return shrinkColumnsToFitAvailableSpace(
+        columns,
+        availableWidth,
+        totalWidth,
+        defaultMinWidth,
+        defaultWidth,
+        flexCount
+      );
+    } else if (totalWidth < availableWidth) {
+      return stretchColumnsToFillAvailableSpace(
+        columns,
+        availableWidth,
+        totalWidth,
+        defaultMaxWidth,
+        defaultWidth
+      );
+    }
+  }
+  return columns;
+}
+const assignMaxWidthToAll = (columns, defaultMaxWidth) => {
+  return columns.map((column) => {
+    const { maxWidth = defaultMaxWidth } = column;
+    if (column.width === maxWidth) {
+      return column;
+    } else {
+      return {
+        ...column,
+        width: maxWidth
+      };
+    }
+  });
+};
+const shrinkColumnsToFitAvailableSpace = (columns, availableWidth, totalWidth, defaultMinWidth, defaultWidth, flexCount) => {
+  const excessWidth = totalWidth - availableWidth;
+  const inFlexMode = flexCount > 0;
+  let excessWidthPerColumn = excessWidth / (flexCount || columns.length);
+  let columnsNotYetAtMinWidth = columns.length;
+  let unassignedExcess = 0;
+  let newColumns = columns.map((column) => {
+    const {
+      minWidth = defaultMinWidth,
+      width = defaultWidth,
+      flex = 0
+    } = column;
+    if (inFlexMode && flex === 0) {
+      return column;
+    }
+    const adjustedWidth = width - excessWidthPerColumn;
+    if (adjustedWidth < minWidth) {
+      columnsNotYetAtMinWidth -= 1;
+      unassignedExcess += minWidth - adjustedWidth;
+      return { ...column, width: minWidth };
+    } else {
+      return { ...column, width: adjustedWidth };
+    }
+  });
+  if (unassignedExcess === 0) {
+    return newColumns;
+  } else {
+    excessWidthPerColumn = unassignedExcess / columnsNotYetAtMinWidth;
+    newColumns = newColumns.map((column) => {
+      const adjustedWidth = column.width - excessWidthPerColumn;
+      if (column.width !== column.minWidth) {
+        return { ...column, width: adjustedWidth };
+      } else {
+        return column;
+      }
+    });
+    return newColumns;
+  }
+};
+const hasFlex = ({ flex }) => typeof flex === "number";
+const stretchColumnsToFillAvailableSpace = (columns, availableWidth, totalWidth, defaultMaxWidth, defaultWidth) => {
+  let freeSpaceToBeFilled = availableWidth - totalWidth;
+  let adjustedColumns = columns;
+  const canGrow = ({
+    width = defaultWidth,
+    maxWidth = defaultMaxWidth
+  }) => width < maxWidth;
+  while (freeSpaceToBeFilled > 0) {
+    const flexCols = adjustedColumns.filter(
+      (col) => hasFlex(col) && canGrow(col)
+    );
+    const columnsNotYetAtMaxWidth = flexCols.length || adjustedColumns.filter(canGrow).length;
+    const additionalWidthPerColumn = Math.ceil(
+      freeSpaceToBeFilled / columnsNotYetAtMaxWidth
+    );
+    adjustedColumns = columns.map((column) => {
+      const {
+        maxWidth = defaultMaxWidth,
+        width = defaultWidth,
+        flex = 0
+      } = column;
+      if (flexCols.length > 0 && flex === 0) {
+        return column;
+      }
+      const adjustmentAmount = Math.min(
+        additionalWidthPerColumn,
+        freeSpaceToBeFilled
+      );
+      const adjustedWidth = width + adjustmentAmount;
+      if (adjustedWidth > maxWidth) {
+        freeSpaceToBeFilled -= adjustedWidth - maxWidth;
+        return { ...column, width: maxWidth };
+      } else {
+        freeSpaceToBeFilled -= adjustmentAmount;
+        return { ...column, width: adjustedWidth };
+      }
+    });
+  }
+  return adjustedColumns;
+};
+const dataAndColumnUnchanged = (p, p1) => p.column === p1.column && p.column.valueFormatter(p.row[p.columnMap[p.column.name]]) === p1.column.valueFormatter(p1.row[p1.columnMap[p1.column.name]]);
+const dataColumnAndKeyUnchanged = (p, p1) => p.column === p1.column && p.row[KEY] === p1.row[KEY] && p.column.valueFormatter(p.row[p.columnMap[p.column.name]]) === p1.column.valueFormatter(p1.row[p1.columnMap[p1.column.name]]);
+const toColumnName = (column) => column.name;
+const isStringColumn = (column) => column.serverDataType === "string";
+const reorderColumnItems = (columnItems, orderedNames) => {
+  const columns = [];
+  for (const name of orderedNames) {
+    const columnItem = columnItems.find((c) => c.name === name);
+    if (columnItem) {
+      columns.push(columnItem);
+    }
+  }
+  return columns;
+};
+
+export { AggregationType, addColumnToSubscribedColumns, applyDefaultColumnConfig, applyGroupByToColumns, applyRuntimeColumnWidthsToConfig, applySortToColumns, applyWidthToColumns, buildColumnMap, checkConfirmationPending, dataAndColumnUnchanged, dataColumnAndKeyUnchanged, dataSourceRowToDataRowDto, existingSort, extractGroupColumn, findColumn, flattenColumnGroup, fromServerDataType, getCalculatedColumnDetails, getColumnLabel, getColumnName, getColumnStyle, getColumnsInViewport, getDefaultAlignment, getDefaultColumnType, getGroupIcon, getGroupValue, getRuntimeColumnWidth, getTableHeadings, getTypeFormattingFromColumn, hasCustomRenderer, hasHeadings, hasValidationRules, isCalculatedColumn, isColumnTypeRenderer, isDataLoading, isDateTimeDataValue, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNotHidden, isNumericColumn, isPinned, isResizing, isStringColumn, isTextColumn, isTypeDescriptor, isValidColumnAlignment, isValidPinLocation, isValueListRenderer, isVuuColumnDataType, mapSortCriteria, measurePinnedColumns, metadataKeys, moveColumnTo, projectUpdates, removeSort, reorderColumnItems, replaceColumn, setAggregations, setCalculatedColumnExpression, setCalculatedColumnName, setCalculatedColumnType, sortPinnedColumns, subscribedOnly, toColumnDescriptor, toColumnName, toDataSourceColumns, updateColumn, updateColumnFormatting, updateColumnRenderProps, updateColumnType, visibleColumnAtIndex };
+//# sourceMappingURL=column-utils.js.map