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

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

@@ -1,970 +0,0 @@
-import { moveItem } from './array-utils.js';
-import { queryClosest } from './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"
-];
-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 isTimestampColumn = ({ serverDataType }) => serverDataType === "epochtimestamp";
-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, serverDataType) => serverDataType === "epochtimestamp" || 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 = 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 moveItem(columns, index, newIndex);
-};
-function replaceColumn(columns, column) {
-  return columns.map((col) => col.name === column.name ? column : col);
-}
-const vuuTimestampColumns = ["vuuCreatedTimestamp", "vuuUpdatedTimestamp"];
-const notVuuTimestamps = (column) => !vuuTimestampColumns.includes(column.name);
-const applyDefaultColumnConfig = ({ columns: columnsProp, table }, getDefaultColumnConfig, includeVuuTimestampColumns = false) => {
-  if (typeof getDefaultColumnConfig === "function") {
-    const columns = includeVuuTimestampColumns ? columnsProp : columnsProp.filter(notVuuTimestamps);
-    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}`);
-};
-
-export { AggregationType, addColumnToSubscribedColumns, applyDefaultColumnConfig, applyGroupByToColumns, applyRuntimeColumnWidthsToConfig, applySortToColumns, applyWidthToColumns, assertAllColumnsAreIncludedInSubscription, buildColumnMap, checkConfirmationPending, columnByAriaIndex, dataAndColumnUnchanged, dataColumnAndKeyUnchanged, dataSourceRowToDataRowDto, existingSort, extractGroupColumn, findColumn, flattenColumnGroup, fromServerDataType, getAllCellsInColumn, getAriaColIndex, getAriaRowIndex, getCalculatedColumnDetails, getColumnLabel, getColumnName, getColumnStyle, getColumnsInViewport, getDefaultAlignment, getDefaultColumnType, getGroupIcon, getGroupValue, getPinStateFromElement, getRuntimeColumnWidth, getServerDataType, getTableHeadings, getTypeFormattingFromColumn, hasCustomRenderer, hasHeadings, hasValidationRules, isCalculatedColumn, isColumnTypeRenderer, isDataLoading, isDateTimeDataType, isDateTimeDataValue, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNotHidden, isNumericColumn, isPinned, isResizing, isStringColumn, isTextColumn, isTimeDataType, isTimeDataValue, isTimestampColumn, 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