@cellaware/utils 8.0.3 → 8.0.4

package/dist/chatwms/datagrid.js

@@ -0,0 +1,781 @@
+import { isDateString } from "../util.js";
+import { CHATWMS_DEFAULT_LANGUAGE } from "./user.js";
+export function initDatagridState() {
+    return {
+        adjRowData: [],
+        chartRowData: []
+    };
+}
+export const DEFAULT_VALUE_FORMAT_VALUE = 'none';
+export function evaluateValueFormat(colFmt, value, locale) {
+    if (value == null)
+        return value;
+    const fmt = colFmt.valueFormat;
+    if (!fmt)
+        return value;
+    try {
+        switch (colFmt.type) {
+            case 'text':
+                return formatText(value, fmt);
+            case 'number':
+                return formatNumber(value, fmt);
+            case 'date':
+                return formatDate(value, fmt, locale);
+            default:
+                return value;
+        }
+    }
+    catch {
+        return value;
+    }
+}
+function formatTextEnabled(fmt) {
+    return fmt.txtCaseVal !== DEFAULT_VALUE_FORMAT_VALUE;
+}
+function formatText(value, fmt) {
+    if (!formatTextEnabled(fmt))
+        return value;
+    const str = String(value);
+    switch (fmt.txtCaseVal) {
+        case 'lower': return str.toLowerCase();
+        case 'upper': return str.toUpperCase();
+        case 'title':
+            return str
+                .toLowerCase()
+                .split(' ')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+        default:
+            return value;
+    }
+}
+export function formatNumberEnabled(fmt) {
+    return fmt.numCommaVal !== DEFAULT_VALUE_FORMAT_VALUE ||
+        fmt.numCurrencyVal !== DEFAULT_VALUE_FORMAT_VALUE ||
+        fmt.numPercentVal !== DEFAULT_VALUE_FORMAT_VALUE ||
+        fmt.numRoundVal !== DEFAULT_VALUE_FORMAT_VALUE;
+}
+function formatNumber(value, fmt) {
+    if (!formatNumberEnabled(fmt))
+        return value;
+    let num = parseFloat(value);
+    if (isNaN(num))
+        return value;
+    /*
+        We need to be intentional about the order of operations for number formatting.
+        For example, some formatting operations will transform the number to a string.
+        If we need to perform some arithmetic or round it, we need to do so first before
+        number is transformed into a string.
+    */
+    if (fmt.numPercentVal === '100') {
+        num *= 100;
+    }
+    const decimals = parseInt(fmt.numRoundVal ?? '', 10);
+    if (!isNaN(decimals)) {
+        num = parseFloat(num.toFixed(decimals));
+    }
+    let formatted = num;
+    if (fmt.numCommaVal === 'on') {
+        formatted = num.toLocaleString();
+    }
+    if (fmt.numCurrencyVal === 'dollar') {
+        formatted = `$${formatted}`;
+    }
+    if (fmt.numPercentVal === '1' || fmt.numPercentVal === '100') {
+        formatted = `${formatted}%`;
+    }
+    return formatted;
+}
+function formatDate(value, fmt, locale) {
+    let valueStr;
+    if (value instanceof Date) {
+        valueStr = value.toISOString();
+    }
+    else {
+        valueStr = String(value);
+    }
+    // Make sure we are dealing with a valid date string before we go any further.
+    if (!isDateString(valueStr)) {
+        return value;
+    }
+    // Remove time zone and milliseconds from date string.
+    valueStr = valueStr.replace(/Z/i, '');
+    valueStr = valueStr.replace(/\.\d+$/, '');
+    // Initialize date options and functionality.
+    const options = { hourCycle: 'h23' };
+    let formatDateEnabled = false;
+    const setOpt = (k, v) => {
+        if (v !== DEFAULT_VALUE_FORMAT_VALUE) {
+            options[k] = v;
+            formatDateEnabled = true;
+        }
+    };
+    setOpt('year', fmt.dteYearVal);
+    setOpt('month', fmt.dteMonthVal);
+    setOpt('day', fmt.dteDayVal);
+    setOpt('weekday', fmt.dteWeekdayVal);
+    setOpt('hour', fmt.dteHourVal);
+    setOpt('minute', fmt.dteMinuteVal);
+    setOpt('second', fmt.dteSecondVal);
+    setOpt('hourCycle', fmt.dteHourcycleVal === 'h24' ? 'h23' : fmt.dteHourcycleVal);
+    // Handle simple date edge cases.
+    if (valueStr.length === 10) {
+        // Special handling for ISO-ish short date string (YYYY-AA-BB or AA-BB-YYYY).
+        const c4 = valueStr.at(4);
+        const c5 = valueStr.at(5);
+        if (c4 === '-' || c4 === '/' || c5 === '-' || c5 === '/') {
+            valueStr += ' 00:00:00'; // Make sure time is zero'd out.
+            if (!formatDateEnabled) {
+                setOpt('day', '2-digit');
+                setOpt('month', '2-digit');
+                setOpt('year', 'numeric');
+            }
+        }
+    }
+    else if (valueStr.length === 8) {
+        // Special handling for ISO-ish shorter date string (YY-MM-DD in any order).
+        const c2 = valueStr.at(2);
+        const c5 = valueStr.at(5);
+        if ((c2 === '-' && c5 === '-') || (c2 === '/' && c5 === '/')) {
+            valueStr += ' 00:00:00'; // Make sure time is zero'd out.
+            if (!formatDateEnabled) {
+                setOpt('day', '2-digit');
+                setOpt('month', '2-digit');
+                setOpt('year', '2-digit');
+            }
+        }
+    }
+    let dteStr = new Date(valueStr).toLocaleString(locale, options);
+    // NOTE: by default, we should use slash as separator.
+    if (fmt.dteSeparatorVal === DEFAULT_VALUE_FORMAT_VALUE) {
+        dteStr = dteStr.replaceAll('-', '/');
+    }
+    else if (fmt.dteSeparatorVal === 'dash') {
+        dteStr = dteStr.replaceAll('/', '-');
+    }
+    else if (fmt.dteSeparatorVal === 'slash') {
+        dteStr = dteStr.replaceAll('-', '/');
+    }
+    dteStr = dteStr.replaceAll(',', '');
+    // We want to preserve simple dates.
+    // If no is formatting detected, the date's length should not be greater than the original value's.
+    if (!formatDateEnabled) {
+        dteStr = dteStr.substring(0, value.length);
+        dteStr = dteStr.trim();
+        // Trim any separator characters off.
+        if (dteStr.endsWith('-') || dteStr.endsWith('/') || dteStr.endsWith(':') || dteStr.endsWith('.') || dteStr.endsWith('T')) {
+            dteStr = dteStr.substring(0, dteStr.length - 1).trim();
+        }
+    }
+    return dteStr;
+}
+export var ConditionalFormatRule;
+(function (ConditionalFormatRule) {
+    // TEXT:
+    ConditionalFormatRule["CONTAINS"] = "conditional-format-rule-contains";
+    ConditionalFormatRule["DOES_NOT_CONTAIN"] = "conditional-format-rule-does-not-contain";
+    ConditionalFormatRule["BEGINS_WITH"] = "conditional-format-rule-begins-with";
+    ConditionalFormatRule["ENDS_WITH"] = "conditional-format-rule-ends-with";
+    // NUMBER:
+    ConditionalFormatRule["GREATER_THAN"] = "conditional-format-rule-greater-than";
+    ConditionalFormatRule["GREATER_THAN_OR_EQUAL_TO"] = "conditional-format-rule-greater-than-or-equal-to";
+    ConditionalFormatRule["LESS_THAN"] = "conditional-format-rule-less-than";
+    ConditionalFormatRule["LESS_THAN_OR_EQUAL_TO"] = "conditional-format-rule-less-than-or-equal-to";
+    ConditionalFormatRule["BETWEEN"] = "conditional-format-rule-between";
+    // ANY:
+    ConditionalFormatRule["EQUALS"] = "conditional-format-rule-equals";
+    ConditionalFormatRule["DOES_NOT_EQUAL"] = "conditional-format-rule-does-not-equal";
+    ConditionalFormatRule["BLANK"] = "conditional-format-rule-blank";
+    ConditionalFormatRule["NOT_BLANK"] = "conditional-format-rule-not-blank";
+})(ConditionalFormatRule || (ConditionalFormatRule = {}));
+export const CONDITIONAL_FORMAT_RULES = [
+    ConditionalFormatRule.EQUALS,
+    ConditionalFormatRule.DOES_NOT_EQUAL,
+    ConditionalFormatRule.BLANK,
+    ConditionalFormatRule.NOT_BLANK,
+    ConditionalFormatRule.CONTAINS,
+    ConditionalFormatRule.DOES_NOT_CONTAIN,
+    ConditionalFormatRule.BEGINS_WITH,
+    ConditionalFormatRule.ENDS_WITH,
+    ConditionalFormatRule.GREATER_THAN,
+    ConditionalFormatRule.GREATER_THAN_OR_EQUAL_TO,
+    ConditionalFormatRule.LESS_THAN,
+    ConditionalFormatRule.LESS_THAN_OR_EQUAL_TO,
+    ConditionalFormatRule.BETWEEN
+];
+export const CONDITIONAL_FORMAT_RULES_TEXT = [
+    ConditionalFormatRule.EQUALS,
+    ConditionalFormatRule.DOES_NOT_EQUAL,
+    ConditionalFormatRule.BLANK,
+    ConditionalFormatRule.NOT_BLANK,
+    ConditionalFormatRule.CONTAINS,
+    ConditionalFormatRule.DOES_NOT_CONTAIN,
+    ConditionalFormatRule.BEGINS_WITH,
+    ConditionalFormatRule.ENDS_WITH
+];
+export const CONDITIONAL_FORMAT_RULES_NUMBER = [
+    ConditionalFormatRule.EQUALS,
+    ConditionalFormatRule.DOES_NOT_EQUAL,
+    ConditionalFormatRule.BLANK,
+    ConditionalFormatRule.NOT_BLANK,
+    ConditionalFormatRule.GREATER_THAN,
+    ConditionalFormatRule.GREATER_THAN_OR_EQUAL_TO,
+    ConditionalFormatRule.LESS_THAN,
+    ConditionalFormatRule.LESS_THAN_OR_EQUAL_TO,
+    ConditionalFormatRule.BETWEEN
+];
+export const CONDITIONAL_FORMAT_RULES_BOOLEAN = [
+    ConditionalFormatRule.EQUALS,
+    ConditionalFormatRule.DOES_NOT_EQUAL,
+    ConditionalFormatRule.BLANK,
+    ConditionalFormatRule.NOT_BLANK
+];
+export function initDatagridCondition() {
+    return {
+        columnName: '',
+        dataType: '',
+        rule: '',
+        value: ''
+    };
+}
+export async function summarizeCondition(condition, localeMessageFn) {
+    let ruleStr = '';
+    switch (condition.rule) {
+        case ConditionalFormatRule.BETWEEN:
+            ruleStr = `${await localeMessageFn(CHATWMS_DEFAULT_LANGUAGE, condition.rule)} ${condition.value} ${await localeMessageFn(CHATWMS_DEFAULT_LANGUAGE, 'conditional-format-rule-and')} ${condition.value2}`;
+            break;
+        case ConditionalFormatRule.BLANK:
+        case ConditionalFormatRule.NOT_BLANK:
+            ruleStr = `${await localeMessageFn(CHATWMS_DEFAULT_LANGUAGE, condition.rule)}`;
+            break;
+        default:
+            if (condition.dataType === 'text') {
+                ruleStr = `${await localeMessageFn(CHATWMS_DEFAULT_LANGUAGE, condition.rule)} '${condition.value}'`;
+            }
+            else {
+                ruleStr = `${await localeMessageFn(CHATWMS_DEFAULT_LANGUAGE, condition.rule)} ${condition.value}`;
+            }
+            break;
+    }
+    return `${condition.columnName} ${ruleStr}`;
+}
+export function codifyCondition(condition) {
+    // NOTE: since we check for action/unsafe SQL with every query, we do not need to check for SQL injection here.
+    if (condition.dataType === 'number') {
+        const v1 = !condition.value || condition.value == '' ? 0 : condition.value;
+        const v2 = !condition.value2 || condition.value2 == '' ? 0 : condition.value2;
+        // Need to wrap in quotes due to how ChatWMS will alias columns (ex: location_id -> Location ID).
+        const quotedColumnName = `"${condition.columnName}"`;
+        switch (condition.rule) {
+            case ConditionalFormatRule.EQUALS:
+                return `${quotedColumnName} = ${v1}`;
+            case ConditionalFormatRule.DOES_NOT_EQUAL:
+                return `${quotedColumnName} != ${v1}`;
+            case ConditionalFormatRule.GREATER_THAN:
+                return `${quotedColumnName} > ${v1}`;
+            case ConditionalFormatRule.GREATER_THAN_OR_EQUAL_TO:
+                return `${quotedColumnName} >= ${v1}`;
+            case ConditionalFormatRule.LESS_THAN:
+                return `${quotedColumnName} < ${v1}`;
+            case ConditionalFormatRule.LESS_THAN_OR_EQUAL_TO:
+                return `${quotedColumnName} <= ${v1}`;
+            case ConditionalFormatRule.BETWEEN:
+                return `${quotedColumnName} BETWEEN ${v1} AND ${v2}`;
+            case ConditionalFormatRule.BLANK:
+                return `${quotedColumnName} IS NULL`;
+            case ConditionalFormatRule.NOT_BLANK:
+                return `${quotedColumnName} IS NOT NULL`;
+            default:
+                return '1 = 2'; // Fail if we get here.
+        }
+    }
+    else if (condition.dataType === 'date') {
+        const v1 = !condition.value || condition.value == '' ? 0 : condition.value;
+        const v2 = !condition.value2 || condition.value2 == '' ? 0 : condition.value2;
+        // Need to wrap in quotes due to how ChatWMS will alias columns (ex: location_id -> Location ID).
+        const quotedColumnName = `"${condition.columnName}"`;
+        switch (condition.rule) {
+            case ConditionalFormatRule.EQUALS:
+                return `${quotedColumnName} = '${v1}'`;
+            case ConditionalFormatRule.DOES_NOT_EQUAL:
+                return `${quotedColumnName} != '${v1}'`;
+            case ConditionalFormatRule.GREATER_THAN:
+                return `${quotedColumnName} > '${v1}'`;
+            case ConditionalFormatRule.GREATER_THAN_OR_EQUAL_TO:
+                return `${quotedColumnName} >= '${v1}'`;
+            case ConditionalFormatRule.LESS_THAN:
+                return `${quotedColumnName} < '${v1}'`;
+            case ConditionalFormatRule.LESS_THAN_OR_EQUAL_TO:
+                return `${quotedColumnName} <= '${v1}'`;
+            case ConditionalFormatRule.BETWEEN:
+                return `${quotedColumnName} BETWEEN '${v1}' AND '${v2}'`;
+            case ConditionalFormatRule.BLANK:
+                return `${quotedColumnName} IS NULL`;
+            case ConditionalFormatRule.NOT_BLANK:
+                return `${quotedColumnName} IS NOT NULL`;
+            default:
+                return '1 = 2'; // Fail if we get here.
+        }
+    }
+    else {
+        // NOTE: it is a safe assumption to trim any whitespace off the value.
+        const v1 = (condition.value ?? '__DUMMY__').trim();
+        // Need to wrap in quotes due to how ChatWMS will alias columns (ex: location_id -> Location ID).
+        // NOTE: wrapping column and values in `UPPER` to support case insensitivity.
+        const quotedColumnName = `UPPER("${condition.columnName}")`;
+        switch (condition.rule) {
+            case ConditionalFormatRule.EQUALS:
+                return `${quotedColumnName} = UPPER('${v1}')`;
+            case ConditionalFormatRule.DOES_NOT_EQUAL:
+                return `${quotedColumnName} != UPPER('${v1}')`;
+            case ConditionalFormatRule.CONTAINS:
+                return `${quotedColumnName} LIKE UPPER('%${v1}%')`;
+            case ConditionalFormatRule.DOES_NOT_CONTAIN:
+                return `${quotedColumnName} NOT LIKE UPPER('%${v1}%')`;
+            case ConditionalFormatRule.BEGINS_WITH:
+                return `${quotedColumnName} LIKE UPPER('${v1}%')`;
+            case ConditionalFormatRule.ENDS_WITH:
+                return `${quotedColumnName} LIKE UPPER('%${v1}')`;
+            case ConditionalFormatRule.BLANK:
+                return `${quotedColumnName} IS NULL`;
+            case ConditionalFormatRule.NOT_BLANK:
+                return `${quotedColumnName} IS NOT NULL`;
+            default:
+                return '1 = 2'; // Fail if we get here.
+        }
+    }
+}
+/**
+ * Equivalent of `parseNumeric` in front end
+ *
+ * https://github.com/cellaware/chatwms-az-swa-ng/blob/development/src/app/utils/data.ts#L126
+ */
+function stripNumericValueFormat(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    // Remove commas, dollar signs, percent signs
+    const cleaned = value.replace(/[$,%]/g, '').replace(/,/g, '');
+    return cleaned;
+}
+function buildDatagridConditionEvaluator(condition) {
+    const v1 = condition.value;
+    const v2 = condition.value2;
+    const isBlank = (v) => v === null || v === undefined || (condition.dataType !== 'number' && condition.dataType !== 'boolean' && v === '');
+    if (condition.dataType === 'number') {
+        switch (condition.rule) {
+            case ConditionalFormatRule.EQUALS:
+                return v => stripNumericValueFormat(v) == v1;
+            case ConditionalFormatRule.DOES_NOT_EQUAL:
+                return v => stripNumericValueFormat(v) != v1;
+            case ConditionalFormatRule.GREATER_THAN:
+                return v => stripNumericValueFormat(v) > v1;
+            case ConditionalFormatRule.GREATER_THAN_OR_EQUAL_TO:
+                return v => stripNumericValueFormat(v) >= v1;
+            case ConditionalFormatRule.LESS_THAN:
+                return v => stripNumericValueFormat(v) < v1;
+            case ConditionalFormatRule.LESS_THAN_OR_EQUAL_TO:
+                return v => stripNumericValueFormat(v) <= v1;
+            case ConditionalFormatRule.BETWEEN:
+                return v => stripNumericValueFormat(v) >= v1 && stripNumericValueFormat(v) <= (v2 ?? v1); // fallback to v1 if v2 missing
+            case ConditionalFormatRule.BLANK:
+                return v => isBlank(v);
+            case ConditionalFormatRule.NOT_BLANK:
+                return v => !isBlank(v);
+            default:
+                return () => false;
+        }
+    }
+    else {
+        switch (condition.rule) {
+            case ConditionalFormatRule.EQUALS:
+                return v => v == v1;
+            case ConditionalFormatRule.DOES_NOT_EQUAL:
+                return v => v != v1;
+            case ConditionalFormatRule.CONTAINS:
+                return v => typeof v === 'string' && v.includes(v1);
+            case ConditionalFormatRule.DOES_NOT_CONTAIN:
+                return v => typeof v === 'string' && !v.includes(v1);
+            case ConditionalFormatRule.BEGINS_WITH:
+                return v => typeof v === 'string' && v.startsWith(v1);
+            case ConditionalFormatRule.ENDS_WITH:
+                return v => typeof v === 'string' && v.endsWith(v1);
+            case ConditionalFormatRule.BLANK:
+                return v => isBlank(v);
+            case ConditionalFormatRule.NOT_BLANK:
+                return v => !isBlank(v);
+            default:
+                return () => false;
+        }
+    }
+}
+function buildPivotDatagridConditionEvaluator(condition, columnNames) {
+    const fn = buildDatagridConditionEvaluator(condition);
+    return row => columnNames.some(columnName => fn(row[columnName]));
+}
+function evaluateDatagridCondition(rows, condition) {
+    const fn = buildDatagridConditionEvaluator(condition);
+    return rows.filter(row => fn(row[condition.columnName]));
+}
+function evaluatePivotDatagridCondition(rows, condition, mappedColumnNames) {
+    let columnNames = [condition.columnName];
+    const mappedColumnNamesSet = mappedColumnNames.get(condition.columnName);
+    if (!!mappedColumnNamesSet) {
+        columnNames = Array.from(mappedColumnNamesSet);
+    }
+    const fn = buildPivotDatagridConditionEvaluator(condition, columnNames);
+    return rows.filter(row => fn(row));
+}
+function parseColumnState(columnState) {
+    const rowGroupCols = [];
+    const pivotCols = [];
+    const valueCols = [];
+    const sortModel = [];
+    for (const col of columnState) {
+        // Row Group Columns:
+        // NOTE: we only want the highest level data.
+        if (col.rowGroup && col.rowGroupIndex === 0) {
+            rowGroupCols.push({
+                field: col.colId
+            });
+        }
+        // Pivot Columns:
+        // NOTE: we only want the highest level data.
+        if (col.pivot && col.pivotIndex === 0) {
+            pivotCols.push({
+                field: col.colId
+            });
+        }
+        // Value Columns (Aggregations):
+        if (col.aggFunc) {
+            valueCols.push({
+                field: col.colId,
+                aggFunc: col.aggFunc
+            });
+        }
+        // Sorting:
+        if (col.sort) {
+            sortModel.push({
+                colId: col.colId,
+                sort: col.sort
+            });
+        }
+    }
+    // NOTE: commenting this out since we only care about the highest level data.
+    // rowGroupCols.sort((a, b) => {
+    //     const iA = columnState.find(c => c.colId === a.field)?.rowGroupIndex ?? 0;
+    //     const iB = columnState.find(c => c.colId === b.field)?.rowGroupIndex ?? 0;
+    //     return iA - iB;
+    // });
+    // pivotCols.sort((a, b) => {
+    //     const iA = columnState.find(c => c.colId === a.field)?.pivotIndex ?? 0;
+    //     const iB = columnState.find(c => c.colId === b.field)?.pivotIndex ?? 0;
+    //     return iA - iB;
+    // });
+    sortModel.sort((a, b) => {
+        const iA = columnState.find(c => c.colId === a.colId)?.sortIndex ?? 0;
+        const iB = columnState.find(c => c.colId === b.colId)?.sortIndex ?? 0;
+        return iA - iB;
+    });
+    return {
+        rowGroupCols,
+        pivotCols,
+        valueCols,
+        sortModel
+    };
+}
+function filterRows(data, filterModel) {
+    const textOps = {
+        equals: (v, f) => (v ?? '').toLowerCase() === f.toLowerCase(),
+        notEqual: (v, f) => (v ?? '').toLowerCase() !== f.toLowerCase(),
+        contains: (v, f) => (v ?? '').toLowerCase().includes(f.toLowerCase()),
+        notContains: (v, f) => !(v ?? '').toLowerCase().includes(f.toLowerCase()),
+        startsWith: (v, f) => (v ?? '').toLowerCase().startsWith(f.toLowerCase()),
+        endsWith: (v, f) => (v ?? '').toLowerCase().endsWith(f.toLowerCase()),
+        blank: (v) => v == null || v === '',
+        notBlank: (v) => !(v == null || v === '')
+    };
+    const numberOps = {
+        equals: (v, f) => v == f,
+        notEqual: (v, f) => v != f,
+        lessThan: (v, f) => v < f,
+        lessThanOrEqual: (v, f) => v <= f,
+        greaterThan: (v, f) => v > f,
+        greaterThanOrEqual: (v, f) => v >= f,
+        inRange: (v, f, t) => v >= f && v <= t,
+        blank: (v) => v == null,
+        notBlank: (v) => v != null
+    };
+    function checkCondition(value, cond) {
+        const { filterType, type, filter, filterTo, values } = cond;
+        if (filterType === 'text') {
+            const fn = textOps[type ?? 'contains'];
+            return fn?.(value, filter);
+        }
+        if (filterType === 'number') {
+            const fn = numberOps[type ?? 'equals'];
+            return type === 'inRange'
+                ? fn?.(value, filter, filterTo)
+                : fn?.(value, filter);
+        }
+        if (filterType === 'set') {
+            // Only boolean types are supported by set filter -- need to represent as string for comparison.
+            return (values ?? []).includes(`${value}`);
+        }
+        return true;
+    }
+    function compilePredicate(model) {
+        return (row) => {
+            return Object.entries(model).every(([field, filter]) => {
+                const value = row[field];
+                if ('conditions' in filter && Array.isArray(filter.conditions)) {
+                    const logicFn = filter.operator === 'OR' ? 'some' : 'every';
+                    return filter.conditions[logicFn](cond => checkCondition(value, cond));
+                }
+                else {
+                    return checkCondition(value, filter);
+                }
+            });
+        };
+    }
+    const predicate = compilePredicate(filterModel);
+    return data.filter(predicate);
+}
+function pivotData(data, rowGroupCols, pivotCols, valueCols) {
+    const groupBy = (row) => Object.fromEntries(rowGroupCols.map(col => [col.field, row[col.field]]));
+    const pivotBy = (row) => pivotCols.map(col => row[col.field]).join('_');
+    const grouped = new Map();
+    for (const row of data) {
+        const groupKey = JSON.stringify(groupBy(row));
+        if (!grouped.has(groupKey))
+            grouped.set(groupKey, []);
+        grouped.get(groupKey).push(row);
+    }
+    const rows = [];
+    const mappedColumnNames = new Map();
+    for (const [groupKey, groupRows] of grouped.entries()) {
+        const groupObj = JSON.parse(groupKey);
+        const pivotBuckets = new Map();
+        for (const row of groupRows) {
+            const pivotKey = pivotBy(row);
+            if (!pivotBuckets.has(pivotKey))
+                pivotBuckets.set(pivotKey, []);
+            pivotBuckets.get(pivotKey).push(row);
+        }
+        for (const [pivotKey, rows] of pivotBuckets.entries()) {
+            for (const { field, aggFunc } of valueCols) {
+                const values = rows.map(r => r[field]).filter(v => v != null);
+                const key = `${pivotKey} ${field}`;
+                let columnNames = mappedColumnNames.get(field);
+                if (!!columnNames) {
+                    columnNames.add(key);
+                }
+                else {
+                    columnNames = new Set([key]);
+                    mappedColumnNames.set(field, columnNames);
+                }
+                switch (aggFunc) {
+                    case 'sum':
+                        groupObj[key] = values.map(Number).reduce((a, b) => a + b, 0);
+                        break;
+                    case 'count':
+                        groupObj[key] = values.length;
+                        break;
+                    case 'min':
+                        groupObj[key] = values.reduce((a, b) => (a < b ? a : b), values[0]);
+                        break;
+                    case 'max':
+                        groupObj[key] = values.reduce((a, b) => (a > b ? a : b), values[0]);
+                        break;
+                    case 'avg': {
+                        const nums = values.map(Number).filter(n => !isNaN(n));
+                        groupObj[key] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                        break;
+                    }
+                    case 'first':
+                        groupObj[key] = values[0];
+                        break;
+                    case 'last':
+                        groupObj[key] = values[values.length - 1];
+                        break;
+                    default:
+                        groupObj[key] = null;
+                }
+            }
+        }
+        rows.push(groupObj);
+    }
+    return { rows, mappedColumnNames };
+}
+function groupAndAggregate(data, rowGroupCols, groupKeys, valueCols) {
+    const level = groupKeys.length;
+    const groupField = rowGroupCols[level]?.field;
+    if (!groupField)
+        return data;
+    const grouped = new Map();
+    for (const row of data) {
+        const key = row[groupField];
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(row);
+    }
+    const output = [];
+    for (const [key, rows] of grouped.entries()) {
+        if (level < rowGroupCols.length - 1) {
+            output.push({
+                group: true,
+                key,
+                children: groupAndAggregate(rows, rowGroupCols, [...groupKeys, key], valueCols)
+            });
+        }
+        else {
+            const aggData = {};
+            for (const { field, aggFunc } of valueCols) {
+                const rawValues = rows.map(r => r[field]).filter(v => v != null);
+                switch (aggFunc) {
+                    case 'sum': {
+                        const nums = rawValues.map(Number).filter(v => !isNaN(v));
+                        aggData[field] = nums.reduce((a, b) => a + b, 0);
+                        break;
+                    }
+                    case 'avg': {
+                        const nums = rawValues.map(Number).filter(v => !isNaN(v));
+                        const total = nums.reduce((a, b) => a + b, 0);
+                        aggData[field] = nums.length > 0 ? total / nums.length : null;
+                        break;
+                    }
+                    case 'min':
+                        aggData[field] = rawValues.reduce((a, b) => (a < b ? a : b), rawValues[0]);
+                        break;
+                    case 'max':
+                        aggData[field] = rawValues.reduce((a, b) => (a > b ? a : b), rawValues[0]);
+                        break;
+                    case 'count':
+                        aggData[field] = rawValues.length;
+                        break;
+                    case 'first':
+                        aggData[field] = rawValues[0];
+                        break;
+                    case 'last':
+                        aggData[field] = rawValues[rawValues.length - 1];
+                        break;
+                    default:
+                        aggData[field] = null;
+                }
+            }
+            // NOTE: we only want the highest level data -- we don't care about child rows.
+            output.push({
+                [groupField]: key,
+                ...aggData,
+                // children: rows
+            });
+        }
+    }
+    return output;
+}
+function sortRows(data, sortModel) {
+    return [...data].sort((a, b) => {
+        for (const { colId, sort } of sortModel) {
+            const valA = a[colId];
+            const valB = b[colId];
+            if (valA === valB)
+                continue;
+            const cmp = valA > valB ? 1 : -1;
+            return sort === 'asc' ? cmp : -cmp;
+        }
+        return 0;
+    });
+}
+export function transformDatagrid(rows, datagridState, locale, condition) {
+    const columnState = datagridState.columnState ?? [];
+    const filterModel = datagridState.filterModel ?? {};
+    const isPivotMode = !!datagridState.isPivotMode;
+    const columnFormats = datagridState.columnFormats ?? [];
+    const { rowGroupCols, pivotCols, valueCols, sortModel } = parseColumnState(columnState);
+    rows = filterRows(rows, filterModel);
+    const chartRowData = [];
+    // IMPORTANT: we evaluate the datagrid condition AFTER we are done with all transformations.
+    if (isPivotMode && pivotCols.length > 0 && valueCols.length > 0) {
+        const pivotOutput = pivotData(rows, rowGroupCols, pivotCols, valueCols);
+        rows = pivotOutput.rows;
+        rows = sortModel.length > 0 ? sortRows(rows, sortModel) : rows;
+        let mappedDisplayColumnNames = new Map();
+        // Should not need to do hidden/visible column analysis -- pivoting creates new results with only the necessary columns.
+        rows.forEach(row => {
+            let chartRow = {};
+            columnFormats.forEach(columnFormat => {
+                if (columnFormat.name in row) {
+                    const value = row[columnFormat.name];
+                    const formattedValue = evaluateValueFormat(columnFormat, row[columnFormat.name], locale);
+                    row[columnFormat.displayName] = formattedValue;
+                    chartRow[columnFormat.displayName] = formatNumberEnabled(columnFormat.valueFormat) ? value : formattedValue;
+                    // Remove name in favor of display name.
+                    if (columnFormat.displayName !== columnFormat.name) {
+                        delete row[columnFormat.name];
+                    }
+                }
+                else {
+                    const mappedColumnNamesSet = pivotOutput.mappedColumnNames.get(columnFormat.name);
+                    if (!!mappedColumnNamesSet) {
+                        const mappedColumnNamesArr = Array.from(mappedColumnNamesSet);
+                        for (const mappedColumnName of mappedColumnNamesArr) {
+                            if (mappedColumnName in row) {
+                                const adjDisplayName = mappedColumnName.replace(columnFormat.name, columnFormat.displayName);
+                                const value = row[mappedColumnName];
+                                const formattedValue = evaluateValueFormat(columnFormat, row[mappedColumnName], locale);
+                                row[adjDisplayName] = formattedValue;
+                                chartRow[adjDisplayName] = formatNumberEnabled(columnFormat.valueFormat) ? value : formattedValue;
+                                // Remove name in favor of display name.
+                                if (adjDisplayName !== mappedColumnName) {
+                                    delete row[mappedColumnName];
+                                }
+                                let displayColumnNames = mappedDisplayColumnNames.get(columnFormat.displayName);
+                                if (!!displayColumnNames) {
+                                    displayColumnNames.add(adjDisplayName);
+                                }
+                                else {
+                                    displayColumnNames = new Set([adjDisplayName]);
+                                    mappedDisplayColumnNames.set(columnFormat.displayName, displayColumnNames);
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            chartRowData.push(chartRow);
+        });
+        if (!!condition) {
+            rows = evaluatePivotDatagridCondition(rows, condition, mappedDisplayColumnNames);
+        }
+    }
+    else {
+        if (rowGroupCols.length > 0) {
+            rows = groupAndAggregate(rows, rowGroupCols, [], valueCols);
+        }
+        rows = sortModel.length > 0 ? sortRows(rows, sortModel) : rows;
+        const hiddenColumnNames = columnState.filter(column => !!column.hide && !column.rowGroup).map(column => column.colId) ?? [];
+        const visibleColumnFormats = columnFormats.filter(column => !hiddenColumnNames.includes(column.name)) ?? [];
+        rows.forEach(row => {
+            let chartRow = {};
+            hiddenColumnNames.forEach(columnName => {
+                delete row[columnName];
+            });
+            visibleColumnFormats.forEach(columnFormat => {
+                const value = row[columnFormat.name];
+                const formattedValue = evaluateValueFormat(columnFormat, row[columnFormat.name], locale);
+                row[columnFormat.displayName] = formattedValue;
+                chartRow[columnFormat.displayName] = formatNumberEnabled(columnFormat.valueFormat) ? value : formattedValue;
+                // Remove name in favor of display name.
+                if (columnFormat.displayName !== columnFormat.name) {
+                    delete row[columnFormat.name];
+                }
+            });
+            chartRowData.push(chartRow);
+        });
+        if (!!condition) {
+            rows = evaluateDatagridCondition(rows, condition);
+        }
+    }
+    return { ...datagridState, adjRowData: rows, chartRowData };
+}