@vuu-ui/vuu-utils 0.8.34 → 0.8.35

package/esm/column-utils.js

@@ -1,738 +0,0 @@
-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 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 isDateTimeColumn = (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 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) && isColumnTypeRenderer(type.renderer) && Array.isArray(type.renderer.rules) && type.renderer.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(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 groupCount = groupBy.length;
-    const groupCols = groupBy.map((name, idx) => {
-      const column = groupedColumns.find(
-        (col) => col.name === name
-      );
-      return {
-        ...column,
-        groupLevel: groupCount - idx
-      };
-    });
-    const groupCol = {
-      name: "group-col",
-      heading: ["group-col"],
-      isGroup: true,
-      columns: groupCols,
-      groupConfirmed: confirmed,
-      width: groupCols.map((c) => c.width).reduce((a, b) => a + b) + 100
-    };
-    return [groupCol, rest];
-  }
-  return [null, flattenColumnGroup(columns)];
-}
-const isGroupColumn = (column) => column.isGroup === true;
-const isJsonAttribute = (value) => typeof value === "string" && 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;
-      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 = (columns, groupBy, confirmed = true) => {
-  if (groupBy.length) {
-    const [groupColumn, nonGroupedColumns] = extractGroupColumn(
-      columns,
-      groupBy,
-      confirmed
-    );
-    if (groupColumn) {
-      return [groupColumn].concat(nonGroupedColumns);
-    }
-  } else if (columns[0]?.isGroup) {
-    return flattenColumnGroup(columns);
-  }
-  return 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)) {
-    return getCalculatedColumnName(column);
-  } 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 getRowRecord = (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 getGroupValueAndOffset = (columns, row, columnMap) => {
-  const { [DEPTH]: depth, [IS_LEAF]: isLeaf } = row;
-  if (isLeaf || depth > columns.length) {
-    return [null, depth === null ? 0 : Math.max(0, depth - 1)];
-  } else if (depth === 0) {
-    return ["$root", 0];
-  } else {
-    const { name, valueFormatter } = columns[depth - 1];
-    const value = valueFormatter(row[columnMap[name]]);
-    return [value, depth - 1];
-  }
-};
-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) => 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)) {
-    return column.name.split(/:=?/);
-  } else {
-    throw Error(
-      `column-utils, getCalculatedColumnDetails column name ${column.name} is not valid calculated column`
-    );
-  }
-};
-const getCalculatedColumnName = (column) => getCalculatedColumnDetails(column)[0];
-const getCalculatedColumnType = (column) => getCalculatedColumnDetails(column)[1];
-const getCalculatedColumnExpression = (column) => getCalculatedColumnDetails(column)[2];
-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 getColumnByName = (schema, name) => {
-  if (name === void 0) {
-    return void 0;
-  } else {
-    const column = schema.columns.find((col) => col.name === name);
-    if (column) {
-      return column;
-    } else {
-      throw Error(
-        `getColumnByName no column '${name}' in schema for ${schema.table.table}`
-      );
-    }
-  }
-};
-function applyWidthToColumns(columns, options) {
-  const {
-    availableWidth = 0,
-    columnLayout = "Static",
-    defaultWidth = DEFAULT_COL_WIDTH,
-    defaultMinWidth = DEFAULT_MIN_WIDTH,
-    defaultMaxWidth = DEFAULT_MAX_WIDTH
-    // defaultFlex = DEFAULT_FLEX,
-  } = options;
-  if (columnLayout === "Static") {
-    return columns.map((column) => {
-      if (typeof column.width === "number") {
-        return column;
-      } else {
-        return {
-          ...column,
-          width: defaultWidth
-        };
-      }
-    });
-  } else if (columnLayout === "Fit") {
-    const { totalMinWidth, totalMaxWidth, totalWidth, flexCount } = columns.reduce(
-      (aggregated, column) => {
-        const { totalMinWidth: totalMinWidth2, totalMaxWidth: totalMaxWidth2, totalWidth: totalWidth2, flexCount: flexCount2 } = aggregated;
-        const {
-          minWidth = defaultMinWidth,
-          maxWidth = defaultMaxWidth,
-          width = defaultWidth,
-          flex = 0
-        } = column;
-        return {
-          totalMinWidth: totalMinWidth2 + minWidth,
-          totalMaxWidth: totalMaxWidth2 + maxWidth,
-          totalWidth: totalWidth2 + width,
-          flexCount: flexCount2 + flex
-        };
-      },
-      { totalMinWidth: 0, totalMaxWidth: 0, totalWidth: 0, flexCount: 0 }
-    );
-    if (totalMinWidth > availableWidth || totalMaxWidth < availableWidth) {
-      return columns;
-    } else if (totalWidth > availableWidth) {
-      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;
-      }
-    } else if (totalWidth < availableWidth) {
-      {
-        const additionalWidth = availableWidth - totalWidth;
-        const inFlexMode = flexCount > 0;
-        let additionalWidthPerColumn = additionalWidth / (flexCount || columns.length);
-        let newColumns = columns.map((column) => {
-          const {
-            maxWidth = defaultMaxWidth,
-            width = defaultWidth,
-            flex = 0
-          } = column;
-          if (inFlexMode && flex === 0) {
-            return column;
-          }
-          const adjustedWidth = width + additionalWidthPerColumn;
-          if (adjustedWidth > maxWidth) {
-            return { ...column, width: maxWidth };
-          } else {
-            return { ...column, width: adjustedWidth, canStretch: true };
-          }
-        });
-        const unassignedAdditionalColumnWidth = additionalWidth - newColumns.reduce((sum, col) => sum + col.width, 0);
-        const columnsNotYetAtMaxWidth = newColumns.filter(
-          (col) => col.canStretch
-        ).length;
-        if (unassignedAdditionalColumnWidth > columnsNotYetAtMaxWidth) {
-          additionalWidthPerColumn = unassignedAdditionalColumnWidth / columnsNotYetAtMaxWidth;
-          newColumns = newColumns.map((column) => {
-            if (column.canStretch) {
-              const adjustedWidth = Math.min(
-                column.width + additionalWidthPerColumn
-              );
-              return { ...column, width: adjustedWidth };
-            } else {
-              return column;
-            }
-          });
-        }
-        return newColumns.map(({ canStretch, ...column }) => column);
-      }
-    }
-  }
-  return columns;
-}
-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]]);
-
-export { AggregationType, addColumnToSubscribedColumns, applyDefaultColumnConfig, applyGroupByToColumns, applySortToColumns, applyWidthToColumns, buildColumnMap, dataAndColumnUnchanged, dataColumnAndKeyUnchanged, existingSort, extractGroupColumn, findColumn, flattenColumnGroup, fromServerDataType, getCalculatedColumnDetails, getCalculatedColumnExpression, getCalculatedColumnName, getCalculatedColumnType, getColumnByName, getColumnLabel, getColumnName, getColumnStyle, getColumnsInViewport, getDefaultAlignment, getDefaultColumnType, getGroupValueAndOffset, getRowRecord, getTableHeadings, getTypeFormattingFromColumn, hasHeadings, hasValidationRules, isCalculatedColumn, isColumnTypeRenderer, isDataLoading, isDateTimeColumn, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNotHidden, isNumericColumn, isPinned, isResizing, isTextColumn, isTypeDescriptor, isValidColumnAlignment, isValidPinLocation, isValueListRenderer, isVuuColumnDataType, mapSortCriteria, measurePinnedColumns, metadataKeys, moveColumnTo, projectUpdates, removeSort, replaceColumn, setAggregations, setCalculatedColumnExpression, setCalculatedColumnName, setCalculatedColumnType, sortPinnedColumns, subscribedOnly, toColumnDescriptor, toDataSourceColumns, updateColumn, updateColumnFormatting, updateColumnRenderProps, updateColumnType, visibleColumnAtIndex };
-//# sourceMappingURL=column-utils.js.map