@vuu-ui/vuu-utils 2.1.19-beta.2 → 2.1.19-beta.4

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

@@ -0,0 +1,1066 @@
+'use strict';
+
+var arrayUtils = require('./array-utils.js');
+var htmlUtils = require('./html-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",
+  "scaleddecimal2",
+  "scaleddecimal4",
+  "scaleddecimal6",
+  "scaleddecimal8",
+  "epochtimestamp",
+  "epochtimestampnano"
+];
+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 isNanoTimestampColumn = ({
+  serverDataType
+}) => serverDataType === "epochtimestampnano";
+const isTimestampColumn = (column) => column.serverDataType === "epochtimestamp" || isNanoTimestampColumn(column);
+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 isDateTimeDataType = (column) => (isTypeDescriptor(column.type) ? column.type.name : column.type) === "date/time";
+const isTimeDataType = (column) => (isTypeDescriptor(column.type) ? column.type.name : column.type) === "time";
+const isDateTimeDataValue = (column) => isTimestampColumn(column) || isDateTimeDataType(column);
+const isTimeDataValue = (column) => (isTypeDescriptor(column?.type) ? column.type.name : column?.type) === "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, serverDataType) => ({
+  name,
+  serverDataType
+});
+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,
+  TIMESTAMP: 8,
+  IS_NEW: 9,
+  count: 10,
+  // 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 (column !== void 0 && isGroupColumn(column)) {
+      return column.groupConfirmed;
+    }
+  }
+};
+const isJsonAttribute = (value) => typeof value === "string" && (value.endsWith("{") || value.endsWith("["));
+const isJsonGroup = (column, dataRow) => column.type?.name === "json" && isJsonAttribute(dataRow[column.name]);
+const isJsonColumn = (column) => column.type?.name === "json";
+const sortPinnedColumns = (columns, selectionBookendWidth = 0) => {
+  const leftPinnedColumns = [];
+  const rightPinnedColumns = [];
+  const restColumns = [];
+  let pinnedWidthLeft = selectionBookendWidth;
+  for (const column of columns) {
+    switch (column.pin) {
+      case "left":
+        {
+          leftPinnedColumns.push({
+            ...column,
+            pinnedWidth: 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(),
+      pinnedWidth: pinnedWidthLeft
+    });
+  }
+  let allColumns = leftPinnedColumns.length ? leftPinnedColumns.concat(restColumns) : restColumns;
+  if (rightPinnedColumns.length) {
+    const measuredRightPinnedColumns = [];
+    let pinnedWidthRight = selectionBookendWidth;
+    for (const column of rightPinnedColumns) {
+      measuredRightPinnedColumns.unshift({
+        ...column,
+        pinnedOffset: pinnedWidthRight
+      });
+      pinnedWidthRight += column.width;
+    }
+    measuredRightPinnedColumns[rightPinnedColumns.length - 1].pinnedWidth = pinnedWidthRight;
+    allColumns = allColumns.concat(measuredRightPinnedColumns);
+  }
+  if (leftPinnedColumns.length || rightPinnedColumns.length) {
+    for (let i = 0; i < allColumns.length; i++) {
+      if (allColumns[i].ariaColIndex !== i + 1) {
+        allColumns[i] = {
+          ...allColumns[i],
+          ariaColIndex: i + 1
+        };
+      }
+    }
+  }
+  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,
+  pinnedOffset = 0,
+  pinnedWidth = 0,
+  width
+}) => {
+  if (pinnedWidth && pin === "left") {
+    return {
+      left: pinnedOffset,
+      width,
+      "--pin-width": `${pinnedWidth - 3}px`
+    };
+  } else if (pin === "left") {
+    return {
+      left: pinnedOffset,
+      width
+    };
+  } else if (pinnedWidth && pin === "right") {
+    return {
+      right: pinnedOffset,
+      width,
+      "--pin-width": `${pinnedWidth - 5}px`
+    };
+  } else if (pin === "right") {
+    return {
+      right: pinnedOffset,
+      width
+    };
+  } else {
+    return { width };
+  }
+};
+const getPinnedWidthFromElement = (cell) => {
+  const cellStyle = getComputedStyle(cell);
+  return parseInt(cellStyle.getPropertyValue("--pin-width"));
+};
+const getAllCellsInColumn = (container, colIndex) => {
+  const byColIndex = `[aria-colindex='${colIndex}']`;
+  return Array.from(
+    container?.querySelectorAll(
+      `.vuuTableCell${byColIndex},.vuuTableHeaderCell${byColIndex},.vuuTableGroupHeaderCell${byColIndex}`
+    ) ?? []
+  );
+};
+const getAriaRowIndex = (rowElement) => {
+  const rowIndex = rowElement?.ariaRowIndex;
+  if (rowIndex != null) {
+    const index = parseInt(rowIndex);
+    if (!isNaN(index)) {
+      return index;
+    }
+  }
+  return -1;
+};
+const getAriaColIndex = (cellElement) => {
+  const colIndex = cellElement?.ariaColIndex;
+  if (colIndex != null) {
+    const index = parseInt(colIndex);
+    if (!isNaN(index)) {
+      return index;
+    }
+  }
+  return -1;
+};
+const getPinDetails = (cell, className) => {
+  if (cell.classList.contains("vuuEndPin")) {
+    return {
+      cell,
+      pinnedWidth: getPinnedWidthFromElement(cell)
+    };
+  } else {
+    const endPin = cell.parentElement?.querySelector(
+      `.${className}.vuuEndPin`
+    );
+    if (endPin) {
+      let pinnedCells = void 0;
+      if (className === "vuuPinLeft") {
+        const container = htmlUtils.queryClosest(
+          cell,
+          ".vuuTable-table",
+          true
+        );
+        const startIndex = getAriaColIndex(cell);
+        const endIndex = getAriaColIndex(endPin);
+        pinnedCells = [];
+        for (let colIndex = startIndex + 1; colIndex <= endIndex; colIndex++) {
+          pinnedCells = pinnedCells?.concat(
+            getAllCellsInColumn(container, colIndex)
+          );
+        }
+      }
+      console.log({ pinnedCells });
+      return {
+        cell: endPin,
+        pinnedCells,
+        pinnedWidth: getPinnedWidthFromElement(endPin)
+      };
+    } else {
+      throw Error(
+        "[column-utils] getPinDetailsFromElement, no endPin on multi column pin"
+      );
+    }
+  }
+};
+const getPinStateFromElement = (cell) => {
+  if (cell.classList.contains("vuuPinLeft")) {
+    return getPinDetails(cell, "vuuPinLeft");
+  } else if (cell.classList.contains("vuuPinRight")) {
+    return getPinDetails(cell, "vuuPinRight");
+  }
+};
+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 (column.pin === "right") {
+      visibleColumns.push(column);
+    } else if (rightPinnedOnly) {
+      continue;
+    } 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 getGroupIcon = (columns, dataRow) => {
+  const { depth, isLeaf } = dataRow;
+  if (isLeaf || depth > columns.length) {
+    return void 0;
+  } else if (depth === 0) {
+    return void 0;
+  } else {
+    const { getIcon } = columns[depth - 1];
+    return getIcon?.(dataRow);
+  }
+};
+const getGroupValue = (columns, dataRow) => {
+  const { depth, isLeaf } = dataRow;
+  if (isLeaf || depth > columns.length) {
+    return null;
+  } else if (depth === 0) {
+    return "$root";
+  } else {
+    const { name, valueFormatter } = columns[depth - 1];
+    const value = valueFormatter(dataRow[name]);
+    return value;
+  }
+};
+const getDefaultColumnType = (serverDataType) => {
+  switch (serverDataType) {
+    case "int":
+    case "long":
+    case "double":
+      return "number";
+    case "scaleddecimal2":
+    case "scaleddecimal4":
+    case "scaleddecimal6":
+    case "scaleddecimal8":
+      return "scaleddecimal";
+    case "boolean":
+      return "boolean";
+    case "epochtimestamp":
+      return "date/time";
+    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 assertAllColumnsAreIncludedInSubscription = (columns, columnNames) => {
+  const unsubscribedColumns = [];
+  for (const column of columns) {
+    if (column.source !== "client" && !columnNames?.includes(column.name)) {
+      unsubscribedColumns.push(column.name);
+    }
+  }
+  if (unsubscribedColumns.length > 0) {
+    throw Error(
+      `[column-utils] assertAllColumnsAreIncludedInSubscription columns not included in subscription: ${unsubscribedColumns.join(", ")}`
+    );
+  }
+};
+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]
+  };
+  return subscribedColumns.concat(newColumn);
+};
+function getServerDataType(column, throwIfUndefined = false) {
+  if (isCalculatedColumn(column.name)) {
+    const { serverDataType } = getCalculatedColumnDetails(column);
+    if (isVuuColumnDataType(serverDataType)) {
+      return serverDataType;
+    } else if (throwIfUndefined) {
+      throw Error(
+        `[column-utils] getServerDataType, calculated column does not have valid type ${column.name}`
+      );
+    }
+  } else if (isVuuColumnDataType(column.serverDataType)) {
+    return column.serverDataType;
+  } else if (throwIfUndefined) {
+    throw Error(
+      `[column-utils] getServerDataType, columns does not have valid type ${column.serverDataType}`
+    );
+  }
+}
+const CalculatedColumnPattern = /.*:.*:.*/;
+const isCalculatedColumn = (columnName) => columnName !== void 0 && CalculatedColumnPattern.test(columnName);
+const getCalculatedColumnDetails = (column) => {
+  const columnName = typeof column === "string" ? column : column.name;
+  if (isCalculatedColumn(columnName)) {
+    const [name, serverDataType, expression] = columnName.split(/:=?/);
+    if (serverDataType && !isVuuColumnDataType(serverDataType)) {
+      throw Error(
+        `column-utils, getCalculatedColumnDetails ${serverDataType} is not valid type for column ${columnName}`
+      );
+    }
+    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, serverDataType) => {
+  const [name, , expression] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${serverDataType}:${expression}`,
+    serverDataType
+  };
+};
+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 arrayUtils.moveItem(columns, index, newIndex);
+};
+function replaceColumn(columns, column) {
+  return columns.map((col) => col.name === column.name ? column : col);
+}
+const vuuDefaultColumns = [
+  "vuuCreatedTimestamp",
+  "vuuUpdatedTimestamp",
+  "vuuMsg"
+];
+const notVuuDefaultColumns = (column) => !vuuDefaultColumns.includes(column.name);
+const applyDefaultColumnConfig = ({ columns: columnsProp, table }, getDefaultColumnConfig, includeVuuDefaultColumns = false) => {
+  if (typeof getDefaultColumnConfig === "function") {
+    const columns = includeVuuDefaultColumns ? columnsProp : columnsProp.filter(notVuuDefaultColumns);
+    return columns.map((column) => {
+      const config = getDefaultColumnConfig(table.table, column.name);
+      if (config) {
+        return {
+          ...column,
+          ...config
+        };
+      } else {
+        return column;
+      }
+    });
+  } else {
+    return columnsProp;
+  }
+};
+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.dataRow[p.column.name]) === p1.column.valueFormatter(p1.dataRow[p1.column.name]);
+const dataColumnAndKeyUnchanged = (p, p1) => p.column === p1.column && p.dataRow.key === p1.dataRow.key && p.column.valueFormatter(p.dataRow[p.column.name]) === p1.column.valueFormatter(p1.dataRow[p1.column.name]);
+const toColumnName = (column) => column.name;
+const isStringColumn = (column) => column.serverDataType === "string";
+const reorderColumnItems = (columnItems, orderedNames) => {
+  const columns = [];
+  let previousName = "";
+  for (const name of orderedNames) {
+    if (previousName !== name) {
+      const columnItem = columnItems.find((c) => c.name === name);
+      if (columnItem) {
+        columns.push(columnItem);
+      }
+      previousName = name;
+    }
+  }
+  return columns;
+};
+const columnByAriaIndex = (columns, ariaColIndex) => {
+  const column = columns[ariaColIndex - 1];
+  if (column && column.ariaColIndex === ariaColIndex) {
+    return column;
+  } else if (column && column.ariaColIndex < ariaColIndex) {
+    if (columns[ariaColIndex]?.ariaColIndex === ariaColIndex) {
+      return columns[ariaColIndex];
+    }
+  }
+  throw Error(`no column with aria-colIndex ${ariaColIndex}`);
+};
+
+exports.AggregationType = AggregationType;
+exports.addColumnToSubscribedColumns = addColumnToSubscribedColumns;
+exports.applyDefaultColumnConfig = applyDefaultColumnConfig;
+exports.applyGroupByToColumns = applyGroupByToColumns;
+exports.applyRuntimeColumnWidthsToConfig = applyRuntimeColumnWidthsToConfig;
+exports.applySortToColumns = applySortToColumns;
+exports.applyWidthToColumns = applyWidthToColumns;
+exports.assertAllColumnsAreIncludedInSubscription = assertAllColumnsAreIncludedInSubscription;
+exports.buildColumnMap = buildColumnMap;
+exports.checkConfirmationPending = checkConfirmationPending;
+exports.columnByAriaIndex = columnByAriaIndex;
+exports.dataAndColumnUnchanged = dataAndColumnUnchanged;
+exports.dataColumnAndKeyUnchanged = dataColumnAndKeyUnchanged;
+exports.dataSourceRowToDataRowDto = dataSourceRowToDataRowDto;
+exports.existingSort = existingSort;
+exports.extractGroupColumn = extractGroupColumn;
+exports.findColumn = findColumn;
+exports.flattenColumnGroup = flattenColumnGroup;
+exports.fromServerDataType = fromServerDataType;
+exports.getAllCellsInColumn = getAllCellsInColumn;
+exports.getAriaColIndex = getAriaColIndex;
+exports.getAriaRowIndex = getAriaRowIndex;
+exports.getCalculatedColumnDetails = getCalculatedColumnDetails;
+exports.getColumnLabel = getColumnLabel;
+exports.getColumnName = getColumnName;
+exports.getColumnStyle = getColumnStyle;
+exports.getColumnsInViewport = getColumnsInViewport;
+exports.getDefaultAlignment = getDefaultAlignment;
+exports.getDefaultColumnType = getDefaultColumnType;
+exports.getGroupIcon = getGroupIcon;
+exports.getGroupValue = getGroupValue;
+exports.getPinStateFromElement = getPinStateFromElement;
+exports.getRuntimeColumnWidth = getRuntimeColumnWidth;
+exports.getServerDataType = getServerDataType;
+exports.getTableHeadings = getTableHeadings;
+exports.getTypeFormattingFromColumn = getTypeFormattingFromColumn;
+exports.hasCustomRenderer = hasCustomRenderer;
+exports.hasHeadings = hasHeadings;
+exports.hasValidationRules = hasValidationRules;
+exports.isCalculatedColumn = isCalculatedColumn;
+exports.isColumnTypeRenderer = isColumnTypeRenderer;
+exports.isDataLoading = isDataLoading;
+exports.isDateTimeDataType = isDateTimeDataType;
+exports.isDateTimeDataValue = isDateTimeDataValue;
+exports.isGroupColumn = isGroupColumn;
+exports.isJsonAttribute = isJsonAttribute;
+exports.isJsonColumn = isJsonColumn;
+exports.isJsonGroup = isJsonGroup;
+exports.isLookupRenderer = isLookupRenderer;
+exports.isMappedValueTypeRenderer = isMappedValueTypeRenderer;
+exports.isNanoTimestampColumn = isNanoTimestampColumn;
+exports.isNotHidden = isNotHidden;
+exports.isNumericColumn = isNumericColumn;
+exports.isPinned = isPinned;
+exports.isResizing = isResizing;
+exports.isStringColumn = isStringColumn;
+exports.isTextColumn = isTextColumn;
+exports.isTimeDataType = isTimeDataType;
+exports.isTimeDataValue = isTimeDataValue;
+exports.isTimestampColumn = isTimestampColumn;
+exports.isTypeDescriptor = isTypeDescriptor;
+exports.isValidColumnAlignment = isValidColumnAlignment;
+exports.isValidPinLocation = isValidPinLocation;
+exports.isValueListRenderer = isValueListRenderer;
+exports.isVuuColumnDataType = isVuuColumnDataType;
+exports.mapSortCriteria = mapSortCriteria;
+exports.measurePinnedColumns = measurePinnedColumns;
+exports.metadataKeys = metadataKeys;
+exports.moveColumnTo = moveColumnTo;
+exports.projectUpdates = projectUpdates;
+exports.removeSort = removeSort;
+exports.reorderColumnItems = reorderColumnItems;
+exports.replaceColumn = replaceColumn;
+exports.setAggregations = setAggregations;
+exports.setCalculatedColumnExpression = setCalculatedColumnExpression;
+exports.setCalculatedColumnName = setCalculatedColumnName;
+exports.setCalculatedColumnType = setCalculatedColumnType;
+exports.sortPinnedColumns = sortPinnedColumns;
+exports.subscribedOnly = subscribedOnly;
+exports.toColumnDescriptor = toColumnDescriptor;
+exports.toColumnName = toColumnName;
+exports.toDataSourceColumns = toDataSourceColumns;
+exports.updateColumn = updateColumn;
+exports.updateColumnFormatting = updateColumnFormatting;
+exports.updateColumnRenderProps = updateColumnRenderProps;
+exports.updateColumnType = updateColumnType;
+exports.visibleColumnAtIndex = visibleColumnAtIndex;
+//# sourceMappingURL=column-utils.js.map