@vuu-ui/vuu-utils 3.0.0 → 3.1.0-beta.1

package/src/column-utils.mjs

@@ -0,0 +1,787 @@
+import { moveItem } from "./array-utils.mjs";
+import { queryClosest } from "./html-utils.mjs";
+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 ("string" == typeof s) return [
+            columnMap[s] + metadataOffset,
+            "asc"
+        ];
+        if (Array.isArray(s)) {
+            const [columnName, sortDir] = s;
+            return [
+                columnMap[columnName] + metadataOffset,
+                sortDir || SORT_ASC
+            ];
+        }
+        throw Error("columnUtils.mapSortCriteria invalid input");
+    });
+}
+const numericTypes = [
+    "int",
+    "long",
+    "double"
+];
+const getDefaultAlignment = (serverDataType)=>void 0 === serverDataType ? "left" : numericTypes.includes(serverDataType) ? "right" : "left";
+const isDataValueEditable = (dataDescriptor, operation, defaultValue = false)=>{
+    const { editable = defaultValue } = dataDescriptor;
+    return "object" == typeof editable ? editable[operation] : true === editable;
+};
+const getRuntimeColumnWidth = (col, runtimeColumns)=>{
+    const runtimeColumn = runtimeColumns.find(({ name })=>name === col.name);
+    if (runtimeColumn) return runtimeColumn.width;
+    return DEFAULT_COL_WIDTH;
+};
+const applyRuntimeColumnWidthsToConfig = (tableConfig, columns)=>({
+        ...tableConfig,
+        columns: columns.map((column)=>({
+                ...column,
+                width: column.width ?? getRuntimeColumnWidth(column, columns)
+            })),
+        columnLayout: "manual"
+    });
+const isValidColumnAlignment = (v)=>"left" === v || "right" === v;
+const isValidPinLocation = (v)=>isValidColumnAlignment(v) || "floating" === v || "" === 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 })=>"epochtimestampnano" === serverDataType;
+const isTimestampColumn = (column)=>"epochtimestamp" === column.serverDataType || isNanoTimestampColumn(column);
+const isNumericColumn = ({ serverDataType, type })=>{
+    if ("int" === serverDataType || "long" === serverDataType || "double" === serverDataType) return true;
+    if ("string" == typeof type) return "number" === type;
+    if ("string" == typeof type?.name) 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)=>"string" == typeof column.pin;
+const hasHeadings = (column)=>Array.isArray(column.heading) && column.heading.length > 0;
+const isResizing = (column)=>column.resizing;
+const isTextColumn = ({ serverDataType })=>void 0 === serverDataType ? false : "char" === serverDataType || "string" === serverDataType;
+const toColumnDescriptor = (name, serverDataType)=>({
+        name,
+        serverDataType
+    });
+const isTypeDescriptor = (type)=>void 0 !== type && "string" != typeof type;
+const EMPTY_COLUMN_MAP = {};
+const isColumnTypeRenderer = (renderer)=>void 0 !== renderer?.name;
+const hasCustomRenderer = (type)=>isTypeDescriptor(type) && isColumnTypeRenderer(type.renderer);
+const isLookupRenderer = (renderer)=>void 0 !== renderer?.name && "lookup" in renderer;
+const isValueListRenderer = (renderer)=>void 0 !== renderer?.name && Array.isArray(renderer.values);
+const hasValidationRules = (type)=>isTypeDescriptor(type) && Array.isArray(type.rules) && type.rules.length > 0;
+const isMappedValueTypeRenderer = (renderer)=>void 0 !== renderer && void 0 !== renderer?.map;
+function buildColumnMap(columns) {
+    const start = metadataKeys.count;
+    if (columns) return columns.reduce((map, column, i)=>{
+        if ("string" == typeof column) map[column] = start + i;
+        else map[column.name] = start + i;
+        return map;
+    }, {});
+    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: KEY,
+    SELECTED: 7,
+    TIMESTAMP: 8,
+    IS_NEW: 9,
+    count: 10,
+    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 ("number" == typeof originalIdx) 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) return columns;
+    {
+        const [groupColumn, ...nonGroupedColumns] = columns;
+        groupColumn.columns.forEach((groupColumn)=>{
+            insertColumn(nonGroupedColumns, groupColumn);
+        });
+        return nonGroupedColumns;
+    }
+};
+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 = 0 === rest.length;
+        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)=>true === column.isGroup;
+const checkConfirmationPending = (previousConfig)=>{
+    if (previousConfig) {
+        const [column] = previousConfig.columns;
+        if (void 0 !== column && isGroupColumn(column)) return column.groupConfirmed;
+    }
+};
+const isJsonAttribute = (value)=>"string" == typeof value && (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;
+        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 ("left" === pin) pinnedWidthLeft += visibleWidth;
+        else if ("right" === pin) 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 })=>Math.max(max, heading?.length ?? 0), 0);
+        let heading;
+        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 && "left" === pin) return {
+        left: pinnedOffset,
+        width,
+        "--pin-width": `${pinnedWidth - 3}px`
+    };
+    if ("left" === pin) return {
+        left: pinnedOffset,
+        width
+    };
+    if (pinnedWidth && "right" === pin) return {
+        right: pinnedOffset,
+        width,
+        "--pin-width": `${pinnedWidth - 5}px`
+    };
+    if ("right" === pin) return {
+        right: pinnedOffset,
+        width
+    };
+    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 (null != rowIndex) {
+        const index = parseInt(rowIndex);
+        if (!isNaN(index)) return index;
+    }
+    return -1;
+};
+const getAriaColIndex = (cellElement)=>{
+    const colIndex = cellElement?.ariaColIndex;
+    if (null != colIndex) {
+        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)
+    };
+    {
+        const endPin = cell.parentElement?.querySelector(`.${className}.vuuEndPin`);
+        if (endPin) {
+            let pinnedCells;
+            if ("vuuPinLeft" === className) {
+                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)
+            };
+        }
+        throw Error("[column-utils] getPinDetailsFromElement, no endPin on multi column pin");
+    }
+};
+const getPinStateFromElement = (cell)=>{
+    if (cell.classList.contains("vuuPinLeft")) return getPinDetails(cell, "vuuPinLeft");
+    if (cell.classList.contains("vuuPinRight")) return getPinDetails(cell, "vuuPinRight");
+};
+const setAggregations = (aggregations, column, aggType)=>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 (void 0 !== sorted) return {
+            ...column,
+            sorted
+        };
+        if (column.sorted) return {
+            ...column,
+            sorted: void 0
+        };
+        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) * ("A" === sortDef.sortType ? 1 : -1) : sortDef.sortType;
+};
+const getColumnName = (name)=>{
+    const pos = name.indexOf(":");
+    if (-1 === pos) return name;
+    return name.slice(0, pos);
+};
+const getColumnLabel = (column)=>{
+    if (column.label) return column.label;
+    if (!isCalculatedColumn(column.name)) return column.name;
+    {
+        const { name } = getCalculatedColumnDetails(column);
+        return name ?? column.name;
+    }
+};
+const findColumn = (columns, columnName)=>{
+    const column = columns.find((col)=>col.name === columnName);
+    if (column) return column;
+    {
+        const groupColumn = columns.find((col)=>col.isGroup);
+        if (groupColumn) return findColumn(groupColumn.columns, columnName);
+    }
+};
+function updateColumn(columns, column, options) {
+    const targetColumn = "string" == typeof column ? 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);
+    }
+    throw Error("column-utils.replaceColun, column not found");
+}
+const toDataSourceColumns = (column)=>column.name;
+const dataSourceRowToDataRowDto = (row, columnMap)=>Object.entries(columnMap).reduce((map, [colName, key])=>{
+        map[colName] = row[key];
+        return map;
+    }, {});
+const isDataLoading = (columns)=>isGroupColumn(columns[0]) && false === columns[0].groupConfirmed;
+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) {
+            if ("right" === column.pin) visibleColumns.push(column);
+            else if (rightPinnedOnly) continue;
+            else if (columnOffset + column.width < vpStart) if ("left" === column.pin) 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)=>true !== column.hidden;
+const visibleColumnAtIndex = (columns, index)=>{
+    if (columns.every(isNotHidden)) return columns[index];
+    return columns.filter(isNotHidden).at(index);
+};
+const getGroupIcon = (columns, dataRow)=>{
+    const { depth, isLeaf } = dataRow;
+    if (isLeaf || depth > columns.length) return;
+    {
+        if (0 === depth) return;
+        const { getIcon } = columns[depth - 1];
+        return getIcon?.(dataRow);
+    }
+};
+const getGroupValue = (columns, dataRow)=>{
+    const { depth, isLeaf } = dataRow;
+    if (isLeaf || depth > columns.length) return null;
+    {
+        if (0 === depth) return "$root";
+        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
+        }
+    };
+    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,
+            renderer
+        }
+    };
+    return {
+        ...column,
+        type: {
+            name: type,
+            renderer
+        }
+    };
+};
+const NO_TYPE_SETTINGS = {};
+const getTypeFormattingFromColumn = (column)=>{
+    if (isTypeDescriptor(column.type)) return column.type.formatting ?? NO_TYPE_SETTINGS;
+    return NO_TYPE_SETTINGS;
+};
+const assertAllColumnsAreIncludedInSubscription = (columns, columnNames)=>{
+    const unsubscribedColumns = [];
+    for (const column of columns)if ("client" !== column.source && 'vuu_action' !== column.name && !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)=>"client" === column.source || columnNames?.includes(column.name);
+const addColumnToSubscribedColumns = (subscribedColumns, availableColumns, columnName)=>{
+    const byColName = (n = columnName)=>(column)=>column.name === n;
+    if (-1 !== subscribedColumns.findIndex(byColName())) throw Error(`[column-utils], addColumnToSubscribedColumns column ${columnName} is already subscribed`);
+    const indexOfAvailableColumn = availableColumns.findIndex(byColName());
+    if (-1 === indexOfAvailableColumn) 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;
+        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)=>void 0 !== columnName && CalculatedColumnPattern.test(columnName);
+const getCalculatedColumnDetails = (column)=>{
+    const columnName = "string" == typeof column ? 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
+        };
+    }
+    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 vuuDefaultColumns = [
+    "vuuCreatedTimestamp",
+    "vuuUpdatedTimestamp",
+    "vuuMsg"
+];
+const notVuuDefaultColumns = (column)=>!vuuDefaultColumns.includes(column.name);
+const applyDefaultColumnConfig = ({ columns: columnsProp, table }, getDefaultColumnConfig, includeVuuDefaultColumns = false)=>{
+    if ("function" != typeof getDefaultColumnConfig) return columnsProp;
+    {
+        const columns = includeVuuDefaultColumns ? columnsProp : columnsProp.filter(notVuuDefaultColumns);
+        return columns.map((column)=>{
+            const config = getDefaultColumnConfig(table.table, column.name);
+            if (config) return {
+                ...column,
+                ...config
+            };
+            return column;
+        });
+    }
+};
+const measureColumns = (columns, defaultMaxWidth, defaultMinWidth)=>columns.reduce((aggregated, column)=>{
+        if (true !== column.hidden) {
+            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 ("fit" === columnLayout) {
+        const { totalMinWidth, totalMaxWidth, totalWidth, flexCount } = measureColumns(columns, defaultMaxWidth, defaultMinWidth);
+        if (totalMaxWidth < availableWidth) return assignMaxWidthToAll(columns, defaultMaxWidth);
+        if (totalMinWidth > availableWidth) ;
+        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)=>columns.map((column)=>{
+        const { maxWidth = defaultMaxWidth } = column;
+        if (column.width === maxWidth) return column;
+        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 && 0 === flex) return column;
+        const adjustedWidth = width - excessWidthPerColumn;
+        if (!(adjustedWidth < minWidth)) return {
+            ...column,
+            width: adjustedWidth
+        };
+        columnsNotYetAtMinWidth -= 1;
+        unassignedExcess += minWidth - adjustedWidth;
+        return {
+            ...column,
+            width: minWidth
+        };
+    });
+    if (0 === unassignedExcess) return newColumns;
+    excessWidthPerColumn = unassignedExcess / columnsNotYetAtMinWidth;
+    newColumns = newColumns.map((column)=>{
+        const adjustedWidth = column.width - excessWidthPerColumn;
+        if (column.width !== column.minWidth) return {
+            ...column,
+            width: adjustedWidth
+        };
+        return column;
+    });
+    return newColumns;
+};
+const hasFlex = ({ flex })=>"number" == typeof flex;
+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 && 0 === flex) return column;
+            const adjustmentAmount = Math.min(additionalWidthPerColumn, freeSpaceToBeFilled);
+            const adjustedWidth = width + adjustmentAmount;
+            if (adjustedWidth > maxWidth) {
+                freeSpaceToBeFilled -= adjustedWidth - maxWidth;
+                return {
+                    ...column,
+                    width: maxWidth
+                };
+            }
+            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)=>"string" === column.serverDataType;
+const columnByAriaIndex = (columns, ariaColIndex)=>{
+    const column = columns[ariaColIndex - 1];
+    if (column && column.ariaColIndex === ariaColIndex) return column;
+    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, isDataValueEditable, isDateTimeDataType, isDateTimeDataValue, isGroupColumn, isJsonAttribute, isJsonColumn, isJsonGroup, isLookupRenderer, isMappedValueTypeRenderer, isNanoTimestampColumn, isNotHidden, isNumericColumn, isPinned, isResizing, isStringColumn, isTextColumn, isTimeDataType, isTimeDataValue, isTimestampColumn, isTypeDescriptor, isValidColumnAlignment, isValidPinLocation, isValueListRenderer, isVuuColumnDataType, mapSortCriteria, measurePinnedColumns, metadataKeys, moveColumnTo, projectUpdates, removeSort, replaceColumn, setAggregations, setCalculatedColumnExpression, setCalculatedColumnName, setCalculatedColumnType, sortPinnedColumns, subscribedOnly, toColumnDescriptor, toColumnName, toDataSourceColumns, updateColumn, updateColumnFormatting, updateColumnRenderProps, updateColumnType, visibleColumnAtIndex };