@quillsql/react 2.11.23 → 2.11.25

package/dist/esm/internals/ReportBuilder/PivotModal.js

@@ -1,16 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// @ts-nocheck
 import { useCallback, useContext, useMemo, useState, useEffect, useRef, } from 'react';
 import { ClientContext } from '../../Context';
 import { getDataFromCloud } from '../../utils/dataFetcher';
 import { PivotList, PivotCard } from './PivotList';
-import { differenceInDays, eachDayOfInterval, eachMonthOfInterval, eachWeekOfInterval, eachYearOfInterval, endOfDay, isWithinInterval, subMilliseconds, min, max, add, } from 'date-fns';
+import { differenceInDays, eachDayOfInterval, eachMonthOfInterval, eachWeekOfInterval, eachYearOfInterval, endOfDay, isWithinInterval, subMilliseconds, add, } from 'date-fns';
 import { valueFormatter } from '../../utils/valueFormatter';
 import { numberFormatOptions, dateFormatOptions } from '../../ChartBuilder';
 import { snakeCaseToTitleCase } from '../../utils/textProcessing';
-import { isIdColumn } from '../../components/ReportBuilder/util';
-import { isNumericColumnType } from '../../components/ReportBuilder/ast';
+import { QuillErrorMessageComponent, QuillPivotColumnContainer, QuillPivotRowContainer, } from '../../components/UiComponents';
+import { isNumericColumnType, isTextColumnType, } from '../../components/ReportBuilder/ast';
 import { QuillCard } from '../../components/QuillCard';
+import { cleanPivot, getPossiblePivotFieldOptions, isValidPivot, } from '../../utils/pivotProcessing';
+import { hashCode } from '../../utils/crypto';
+import { getUniqueValuesByColumns } from '../../utils/tableProcessing';
 const QuillHover = () => {
     return (_jsx("style", { children: `
   .quill-hover {
@@ -24,57 +26,158 @@ const QuillHover = () => {
   }
 ` }));
 };
-export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField, setPivotColumnField, pivotValueField, setPivotValueField, pivotAggregation, setPivotAggregation, popUpTitle, setPopUpTitle, selectedTable, SelectComponent, ButtonComponent, SecondaryButtonComponent, PopoverComponent, CardComponent = QuillCard, HeaderComponent, LabelComponent, TextComponent, selectedPivotIndex, setSelectedPivotIndex, removePivot, selectPivot, showUpdatePivot, setShowUpdatePivot, data, columns, theme, isOpen, setIsOpen, dateRange, createdPivots, setCreatedPivots, recommendedPivots, setRecommendedPivots, triggerButtonText = 'Pivot', showPivotEditButton = false, showEditOnPivotClick = true, selectPivotOnEdit = false, showTrigger = true, rightAlign = false, parentRef, recommendPivotCount = 6, }) => {
+export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField, setPivotColumnField, pivotValueField, setPivotValueField, pivotAggregation, setPivotAggregation, popUpTitle, setPopUpTitle, selectedTable, SelectComponent, ButtonComponent, SecondaryButtonComponent, PopoverComponent, ErrorMessageComponent = QuillErrorMessageComponent, PivotRowContainer = QuillPivotRowContainer, PivotColumnContainer = QuillPivotColumnContainer, CardComponent = QuillCard, HeaderComponent, LabelComponent, TextComponent, selectedPivotIndex, setSelectedPivotIndex, removePivot, selectPivot, showUpdatePivot, setShowUpdatePivot, data, columns, theme, isOpen, setIsOpen, dateRange, createdPivots, setCreatedPivots, recommendedPivots, setRecommendedPivots, triggerButtonText = 'Pivot', showPivotEditButton = false, showEditOnPivotClick = true, selectPivotOnEdit = false, showTrigger = true, rightAlign = false, parentRef, pivotCountRequest = 6, query, initialUniqueValues, initialSelectedPivotTable, disabled = false, pivotRecommendationsEnabled = true, }) => {
     const [isLoading, setIsLoading] = useState(false);
-    const [pivotUpdateIndex, setPivotUpdateIndex] = useState(null);
     const [selectedPivotType, setSelectedPivotType] = useState('recommended');
     const [errors, setErrors] = useState([]);
     const [client] = useContext(ClientContext);
+    const rowFieldRef = useRef(null);
+    const colFieldRef = useRef(null);
+    const [pivotCardWidth, setPivotCardWidth] = useState(420);
     const [divWidth, setDivWidth] = useState(0);
-    const editModalRef = useRef();
-    const calculateWidth = () => {
-        return editModalRef.current.offsetWidth;
+    const [samplePivotTable, setSamplePivotTable] = useState(null);
+    const [allowedColumnFields, setAllowedColumnFields] = useState([]);
+    const [allowedRowFields, setAllowedRowFields] = useState([]);
+    const [allowedValueFields, setAllowedValueFields] = useState([]);
+    const [uniqueValues, setUniqueValues] = useState(initialUniqueValues);
+    const getDistinctValues = async () => {
+        if (columns) {
+            const stringColumns = columns.filter((column) => {
+                return isTextColumnType(column.fieldType || column.format);
+            });
+            if (stringColumns.length === 0) {
+                const possibleColumns = getPossiblePivotFieldOptions(columns, {});
+                setAllowedRowFields(possibleColumns.rowFields);
+                setAllowedColumnFields(possibleColumns.columnFields);
+                setAllowedValueFields(possibleColumns.valueFields);
+                return possibleColumns;
+            }
+            const newUniqueValues = await getUniqueValuesByColumns(stringColumns, query || '', data.rows || [], client);
+            if (!uniqueValues ||
+                hashCode(uniqueValues) !== hashCode(newUniqueValues)) {
+                const possibleColumns = getPossiblePivotFieldOptions(columns, newUniqueValues || {});
+                setAllowedRowFields(possibleColumns.rowFields);
+                setAllowedColumnFields(possibleColumns.columnFields);
+                setAllowedValueFields(possibleColumns.valueFields);
+                setUniqueValues(newUniqueValues);
+                return possibleColumns;
+            }
+        }
+        return { rowFields: [], columnFields: [], valueFields: [] };
     };
     useEffect(() => {
-        // Measure the width of the div and update state
-        if (editModalRef.current) {
-            setDivWidth(calculateWidth());
-        }
-        // Optional: Handle window resize
-        const handleResize = () => {
-            if (editModalRef.current) {
-                setDivWidth(calculateWidth());
+        const calculatePivotCardSize = () => {
+            // The pivot card should be the same width as the row of inputs
+            // below it (two selects, plus the gap between them).
+            if (rowFieldRef.current && colFieldRef.current) {
+                const rowFieldSize = rowFieldRef.current?.getBoundingClientRect();
+                const colFieldSize = colFieldRef.current?.getBoundingClientRect();
+                const selectWidth = rowFieldSize.width;
+                const gap = colFieldSize.left - rowFieldSize.right;
+                const width = 2 * selectWidth + gap;
+                setPivotCardWidth(width);
             }
         };
-        window.addEventListener('resize', handleResize);
-        // Cleanup listener
-        return () => {
-            window.removeEventListener('resize', handleResize);
-        };
+        if (rowFieldRef.current && colFieldRef.current) {
+            calculatePivotCardSize();
+        }
+        else {
+            setTimeout(() => {
+                calculatePivotCardSize();
+            }, 500);
+        }
+    }, [showUpdatePivot, isOpen]);
+    useEffect(() => {
+        if (pivotRowField && data && columns) {
+            const pivot = {
+                rowField: pivotRowField || '',
+                rowFieldType: columnsToShow[pivotRowField || ''],
+                columnField: pivotColumnField,
+                columnFieldType: columnsToShow[pivotColumnField || ''],
+                valueField: pivotValueField || '',
+                aggregationType: pivotAggregation || '',
+            };
+            const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
+            setSamplePivotTable({ pivot: pivot, rows, columns });
+        }
+        if ((pivotRowField && data && columns) || initialSelectedPivotTable) {
+            getDistinctValues();
+        }
+        if (initialUniqueValues) {
+            const possibleColumns = getPossiblePivotFieldOptions(columns, initialUniqueValues);
+            setAllowedRowFields(possibleColumns.rowFields);
+            setAllowedColumnFields(possibleColumns.columnFields);
+            setAllowedValueFields(possibleColumns.valueFields);
+            setUniqueValues(initialUniqueValues);
+        }
+        if (pivotRowField && data && columns) {
+            const pivot = {
+                rowField: pivotRowField || '',
+                rowFieldType: columnsToShow[pivotRowField || ''],
+                columnField: pivotColumnField,
+                columnFieldType: columnsToShow[pivotColumnField || ''],
+                valueField: pivotValueField || '',
+                aggregationType: pivotAggregation || '',
+            };
+            if (initialSelectedPivotTable) {
+                setSamplePivotTable({
+                    pivot: pivot,
+                    rows: initialSelectedPivotTable.rows,
+                    columns: initialSelectedPivotTable.columns,
+                });
+            }
+            else {
+                const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
+                setSamplePivotTable({ pivot: pivot, rows, columns });
+            }
+        }
     }, []);
     useEffect(() => {
-        // Measure the width of the div and update state
-        if (editModalRef.current) {
-            setDivWidth(calculateWidth());
+        const pivot = {
+            rowField: pivotRowField || '',
+            rowFieldType: columnsToShow[pivotRowField || ''],
+            columnField: pivotColumnField,
+            columnFieldType: columnsToShow[pivotColumnField || ''],
+            valueField: pivotValueField || '',
+            aggregationType: pivotAggregation || '',
+        };
+        if (isValidPivot(pivot) && data && columns) {
+            const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
+            setSamplePivotTable({ pivot: pivot, rows, columns });
         }
-    }, [editModalRef.current, showUpdatePivot]);
+    }, [
+        data,
+        columns,
+        pivotRowField,
+        pivotColumnField,
+        pivotValueField,
+        pivotAggregation,
+    ]);
     useEffect(() => {
         setSelectedPivotIndex(-1);
-        setPivotUpdateIndex(null);
-        setSelectedPivotType(undefined);
+        setSelectedPivotType('');
         setPivotRowField(undefined);
         setPivotColumnField(undefined);
         setPivotValueField(undefined);
         setPivotAggregation(undefined);
-        setIsOpen(false);
         setErrors([]);
     }, [selectedTable]);
+    useEffect(() => {
+        if (!initialUniqueValues) {
+            return;
+        }
+        const possibleColumns = getPossiblePivotFieldOptions(columns, initialUniqueValues);
+        setAllowedRowFields(possibleColumns.rowFields);
+        setAllowedColumnFields(possibleColumns.columnFields);
+        setAllowedValueFields(possibleColumns.valueFields);
+        setUniqueValues(initialUniqueValues);
+    }, [initialUniqueValues, columns]);
     const columnsToShow = useMemo(() => {
         return (columns || []).reduce((map, col) => {
             // only use columns shown in the report builder's table
             // also filter out id
             if (col.field !== 'id') {
-                map[col.field] = col.fieldType || col.format;
+                map[col.field] = col.format;
             }
             return map;
         }, {});
@@ -84,20 +187,13 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
             return null;
         }
         const pivot = createdPivots[selectedPivotIndex];
-        const { rows, columns } = generatePivotTable(pivot, data, dateRange);
+        const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
         return {
             pivot: pivot,
             rows: rows,
             columns: columns,
         };
     }, [selectedPivotIndex, data, dateRange, createdPivots]);
-    const columnSelectOptions = useMemo(() => {
-        return [
-            ...Object.keys(columnsToShow).map((key) => {
-                return { label: snakeCaseToTitleCase(key), value: key };
-            }),
-        ];
-    }, [columnsToShow]);
     const onSelectRecommendedPivot = (pivot, index) => {
         if (showEditOnPivotClick) {
             onEditPivot(pivot, index);
@@ -116,28 +212,47 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
         selectPivot(pivot);
         setSelectedPivotType('created');
         setIsOpen(false);
-        setPopUpTitle('Add Pivot');
+        setPopUpTitle('Add pivot');
     };
     const onEditPivot = (pivot, index) => {
         setPivotRowField(pivot.rowField);
         setPivotColumnField(pivot.columnField);
         setPivotValueField(pivot.valueField);
         setPivotAggregation(pivot.aggregationType);
-        setPivotUpdateIndex(index);
         setShowUpdatePivot(true);
+        if (isValidPivot(pivot)) {
+            const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
+            setSamplePivotTable({ pivot, rows, columns });
+            return;
+        }
+        setSamplePivotTable(null);
     };
     const onEditRecommendedPivot = (pivot, index) => {
         onEditPivot(pivot, null);
     };
     const refreshPivots = useCallback(async () => {
-        if (!showTrigger) {
-            return;
-        }
-        if (isLoading || Object.keys(columnsToShow).length === 0) {
+        if (isLoading ||
+            Object.keys(columnsToShow).length === 0 ||
+            !pivotRecommendationsEnabled) {
             return;
         }
         setIsLoading(true);
+        let possibleColumns = {
+            rowFields: allowedRowFields,
+            columnFields: allowedColumnFields,
+            valueFields: allowedValueFields,
+        };
+        if ((allowedRowFields.length === 0 &&
+            allowedColumnFields.length === 0 &&
+            allowedValueFields.length === 0) ||
+            !uniqueValues) {
+            possibleColumns = await getDistinctValues();
+        }
         const cloudBody = {
+            pivotCountRequest,
+            allowedRowFields: possibleColumns?.rowFields || [],
+            allowedColumnFields: possibleColumns?.columnFields || [],
+            allowedValueFields: possibleColumns?.valueFields || [],
             tableSchema: Object.keys(columnsToShow).reduce(function (map, col) {
                 // stop ai from seeing date fields. this is meant to stop the ai
                 // pivot tables from extracting month and year from the date
@@ -150,11 +265,10 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
         };
         try {
             const resp = await getDataFromCloud(client, 'pivotai', cloudBody);
-            const recommendedPivots = resp?.data?.pivotTables.slice(0, recommendPivotCount) || [];
-            setRecommendedPivots(recommendedPivots
-                .filter((pivot) => pivot.rowField != '')
-                .map((pivot) => {
-                if (columnsToShow[pivot.columnField] === 'date') {
+            const recommendedPivots = resp?.data?.pivotTables.map((pivot) => cleanPivot(pivot, possibleColumns)) || [];
+            setRecommendedPivots(recommendedPivots.map((pivot) => {
+                if (pivot.columnField &&
+                    columnsToShow[pivot.columnField] === 'date') {
                     const columnField = pivot.columnField;
                     pivot.columnField = pivot.rowField;
                     pivot.rowField = columnField;
@@ -162,57 +276,71 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
                 return {
                     ...pivot,
                     rowFieldType: columnsToShow[pivot.rowField],
-                    columnFieldType: columnsToShow[pivot.columnField],
+                    columnFieldType: pivot.columnField
+                        ? columnsToShow[pivot.columnField]
+                        : undefined,
+                    title: generatePivotTitle(pivot),
                 };
             }));
-            // refreshing means the currently selected pivot doesn't exist in the options anymore
             setSelectedPivotIndex(-1);
         }
         catch (e) {
             console.error('Failed parsing pivotai response', e);
         }
         setIsLoading(false);
-    }, [selectedTable, data, columnsToShow, isLoading, showTrigger]);
-    useEffect(() => {
-        if (recommendedPivots.length === 0) {
-            refreshPivots();
+    }, [
+        selectedTable,
+        data,
+        columnsToShow,
+        isLoading,
+        showTrigger,
+        allowedColumnFields,
+        allowedRowFields,
+        allowedValueFields,
+    ]);
+    const pivotFieldChange = async (field, value) => {
+        setIsLoading(true);
+        const pivot = {
+            rowField: pivotRowField,
+            rowFieldType: columnsToShow[pivotRowField],
+            columnField: pivotColumnField,
+            valueField: pivotValueField,
+            aggregationType: pivotAggregation,
+        };
+        // @ts-ignore
+        pivot[field] = value;
+        pivot.title = generatePivotTitle(pivot);
+        if (field === 'rowField') {
+            pivot.rowFieldType = columnsToShow[value];
         }
-    }, []);
+        else if (field === 'columnField') {
+            pivot.columnFieldType = columnsToShow[value];
+        }
+        if (!isValidPivot(pivot)) {
+            setIsLoading(false);
+            setSamplePivotTable(null);
+            return;
+        }
+        setTimeout(() => {
+            const { rows, columns } = generatePivotTable(pivot, data, dateRange, false);
+            setSamplePivotTable({ pivot, rows, columns });
+            setIsLoading(false);
+        }, 500);
+    };
     const recommendedPivotTables = useMemo(() => {
         const pts = recommendedPivots.map((p) => {
-            const { rows, columns } = generatePivotTable(p, data, dateRange, 6);
+            const { rows, columns } = generatePivotTable(p, data, dateRange, false, 6);
             return { pivot: p, rows, columns };
         });
         return pts;
     }, [recommendedPivots, data]);
     const createdPivotTables = useMemo(() => {
         const pts = createdPivots.map((p) => {
-            const { rows, columns } = generatePivotTable(p, data, dateRange, 6);
+            const { rows, columns } = generatePivotTable(p, data, dateRange, false, 6);
             return { pivot: p, rows, columns };
         });
         return pts;
     }, [createdPivots, data]);
-    const samplePivotTable = useMemo(() => {
-        if (!pivotAggregation) {
-            return null;
-        }
-        const pivot = {
-            rowField: pivotRowField || '',
-            rowFieldType: columnsToShow[pivotRowField || ''],
-            columnField: pivotColumnField,
-            columnFieldType: columnsToShow[pivotColumnField || ''],
-            valueField: pivotValueField || '',
-            aggregationType: pivotAggregation || '',
-        };
-        const { rows, columns } = generatePivotTable(pivot, data, dateRange);
-        return { pivot: pivot, rows, columns };
-    }, [
-        pivotAggregation,
-        pivotValueField,
-        pivotRowField,
-        pivotColumnField,
-        columnsToShow,
-    ]);
     return (_jsx("div", { style: { display: 'flex', flexDirection: 'column' }, children: _jsxs("div", { style: {
                 position: 'relative',
                 display: 'inline-block',
@@ -229,7 +357,7 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
                             position: 'absolute',
                             top: -2,
                             right: -2,
-                        } })) }), showTrigger && (_jsx(SecondaryButtonComponent, { onClick: () => {
+                        } })) }), showTrigger && (_jsx(SecondaryButtonComponent, { disabled: disabled, onClick: () => {
                         if (columns.length === 0) {
                             setIsOpen(false);
                         }
@@ -242,149 +370,26 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
                         }
                         setIsOpen(!isOpen);
                         setShowUpdatePivot(false);
-                    }, label: triggerButtonText })), _jsx(PopoverComponent, { isOpen: isOpen, setIsOpen: (isOpen) => {
-                        if (!isOpen) {
-                            setShowUpdatePivot(false);
-                            setPopUpTitle('Add Pivot');
-                        }
-                        setIsOpen(isOpen);
-                    }, popoverTitle: showUpdatePivot ? popUpTitle : 'Recommended pivots', popoverChildren: _jsx("div", { style: {
-                            paddingTop: showUpdatePivot ? 0 : 20,
-                            position: 'relative',
-                        }, children: showUpdatePivot ? (_jsxs("div", { className: "ref-in-use", ref: editModalRef, style: {
-                                backgroundColor: 'rgb(255, 255, 255)',
-                                display: 'flex',
-                                flexDirection: 'column',
-                            }, children: [_jsx("div", { style: { height: 12 } }), _jsx("div", { style: { width: divWidth }, children: samplePivotTable && (_jsx("div", { style: {
-                                            marginBottom: 20,
-                                            minHeight: 160,
-                                        }, children: _jsx(PivotCard, { pivotTable: samplePivotTable, theme: theme, index: 0, selectedPivotIndex: -1, onEditPivot: () => { }, ButtonComponent: ButtonComponent, showEdit: false, clickable: false, minHeight: 140, LabelComponent: LabelComponent, TextComponent: TextComponent, HeaderComponent: HeaderComponent, CardComponent: CardComponent }) })) }), _jsxs("div", { style: {
-                                        display: 'flex',
-                                        flexDirection: 'column',
-                                        gap: 10,
-                                        alignItems: 'center',
-                                        justifyContent: 'space-between',
-                                    }, children: [_jsxs("div", { style: {
-                                                display: 'flex',
-                                                flexDirection: 'row',
-                                                gap: 20,
-                                                marginBottom: 5,
-                                            }, children: [_jsxs("div", { children: [_jsx(LabelComponent, { label: "Row Field" }), _jsx(SelectComponent, { id: "pivot-row-field", value: pivotRowField, onChange: (e) => {
-                                                                setPivotRowField(e.target.value === ''
-                                                                    ? undefined
-                                                                    : e.target.value);
-                                                            }, options: [
-                                                                ...columnSelectOptions.filter((option) => {
-                                                                    const format = columns.find((col) => col.field === option.value)?.format;
-                                                                    return (format === 'string' ||
-                                                                        dateFormatOptions.includes(format) ||
-                                                                        isIdColumn(option.value));
-                                                                }),
-                                                            ], width: 200 })] }), _jsxs("div", { children: [_jsx(LabelComponent, { label: "Column Field" }), _jsx(SelectComponent, { id: "pivot-row-field", value: pivotColumnField, onChange: (e) => {
-                                                                setPivotColumnField(e.target.value === ''
-                                                                    ? undefined
-                                                                    : e.target.value);
-                                                            }, options: [
-                                                                ...columnSelectOptions.filter((option) => {
-                                                                    return (columns.find((col) => col.field === option.value)?.format === 'string');
-                                                                }),
-                                                            ], width: 200 })] })] }), _jsxs("div", { style: {
-                                                display: 'flex',
-                                                flexDirection: 'row',
-                                                gap: 20,
-                                                marginBottom: 20,
-                                            }, children: [_jsxs("div", { children: [_jsx(LabelComponent, { label: "Value Field" }), _jsx(SelectComponent, { id: "pivot-row-field", value: pivotValueField, onChange: (e) => {
-                                                                setPivotValueField(e.target.value === ''
-                                                                    ? undefined
-                                                                    : e.target.value);
-                                                            }, options: [
-                                                                ...columnSelectOptions.filter((option) => {
-                                                                    return ((option.value === '' ||
-                                                                        numberFormatOptions.includes(columns.find((col) => col.field === option.value)?.format)) &&
-                                                                        !isIdColumn(option.value));
-                                                                }),
-                                                            ], width: 200 })] }), _jsxs("div", { children: [_jsx(LabelComponent, { label: "Aggregation Type" }), _jsx(SelectComponent, { id: "pivot-row-field", value: pivotAggregation, onChange: (e) => {
-                                                                if (e.target.value !== 'count' &&
-                                                                    pivotValueField &&
-                                                                    !numberFormatOptions.includes(columns.find((col) => col.field === pivotValueField)?.format)) {
-                                                                    setPivotValueField(null);
-                                                                }
-                                                                setPivotAggregation(e.target.value === ''
-                                                                    ? undefined
-                                                                    : e.target.value);
-                                                            }, options: [
-                                                                ...['sum', 'average', 'count', 'max', 'min'].map((option) => {
-                                                                    return { label: option, value: option };
-                                                                }),
-                                                            ], width: 200 })] })] })] }), _jsx("div", { children: _jsx(ButtonComponent, { id: "custom-button", onClick: () => {
-                                            const errors = [];
-                                            if (!pivotValueField && pivotAggregation !== 'count') {
-                                                errors.push("Value field cannot be empty when aggregation is not 'count'");
-                                            }
-                                            if (!pivotAggregation) {
-                                                errors.push('Aggregation cannot be empty');
-                                            }
-                                            if (errors.length === 0) {
-                                                const pivot = {
-                                                    rowField: pivotRowField || '',
-                                                    rowFieldType: columnsToShow[pivotRowField || ''],
-                                                    columnField: pivotColumnField,
-                                                    columnFieldType: columnsToShow[pivotColumnField || ''],
-                                                    valueField: pivotValueField || '',
-                                                    aggregationType: pivotAggregation || '',
-                                                };
-                                                pivot.title = generatePivotTitle(pivot);
-                                                setIsOpen(false);
-                                                setCreatedPivots([pivot]);
-                                                onSelectCreatedPivot(pivot, 0);
-                                                setPopUpTitle('Add Pivot');
-                                            }
-                                            setErrors(errors);
-                                        }, label: popUpTitle }) }), _jsx("div", { children: errors.length > 0 && (_jsxs("div", { children: [_jsx("div", { style: {
-                                                    paddingTop: '8px',
-                                                } }), errors.map((error, index) => (_jsx("div", { style: {
-                                                    borderRadius: 8,
-                                                    backgroundColor: '#FF9494',
-                                                    paddingLeft: '12px',
-                                                    paddingRight: '8px',
-                                                    height: 30,
-                                                    display: 'flex',
-                                                    alignItems: 'center',
-                                                    fontSize: 13,
-                                                    fontWeight: 'bold',
-                                                    fontFamily: theme?.fontFamily,
-                                                    color: 'white',
-                                                    marginBottom: 5,
-                                                }, children: error }, index)))] })) })] })) : (_jsx("div", { style: {
-                                display: 'flex',
-                                flexDirection: 'column',
-                                fontFamily: theme?.fontFamily,
-                                color: theme?.primaryTextColor,
-                                width: selectedPivotTable ? 500 : 600,
-                                maxHeight: 600,
-                                overflowY: 'scroll',
-                            }, children: selectedPivotIndex >= 0 ? (_jsx("div", { children: _jsx("div", { onClick: () => {
-                                        setPopUpTitle('Edit Pivot');
-                                        onEditPivot(createdPivots[0], 0);
-                                    }, children: _jsx(PivotCard, { pivotTable: {
-                                            pivot: selectedPivotTable?.pivot,
-                                            rows: selectedPivotTable?.rows,
-                                            columns: selectedPivotTable?.columns,
-                                        }, theme: theme, index: 0, onSelectPivot: () => { }, selectedPivotIndex: -1, onEditPivot: () => { }, ButtonComponent: ButtonComponent, showEdit: false, onClose: () => {
-                                            removePivot();
-                                        }, clickable: true, minHeight: 180, CardComponent: CardComponent, LabelComponent: LabelComponent, TextComponent: TextComponent, HeaderComponent: HeaderComponent }) }) })) : (_jsxs("div", { style: { display: 'flex', flexDirection: 'column' }, children: [_jsx("div", { style: {
-                                            // position button inline with the popover title
-                                            position: 'absolute',
-                                            top: -36,
-                                            right: 0,
-                                        }, children: _jsx(SecondaryButtonComponent, { onClick: refreshPivots, label: _jsxs("div", { style: {
-                                                    display: 'flex',
-                                                    flexDirection: 'row',
-                                                    whiteSpace: 'nowrap',
-                                                    alignItems: 'center',
-                                                    gap: 6,
-                                                    fontSize: 14,
-                                                }, children: [_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", style: { width: 16, height: 16 }, children: _jsx("path", { fillRule: "evenodd", d: "M9 4.5a.75.75 0 0 1 .721.544l.813 2.846a3.75 3.75 0 0 0 2.576 2.576l2.846.813a.75.75 0 0 1 0 1.442l-2.846.813a3.75 3.75 0 0 0-2.576 2.576l-.813 2.846a.75.75 0 0 1-1.442 0l-.813-2.846a3.75 3.75 0 0 0-2.576-2.576l-2.846-.813a.75.75 0 0 1 0-1.442l2.846-.813A3.75 3.75 0 0 0 7.466 7.89l.813-2.846A.75.75 0 0 1 9 4.5ZM18 1.5a.75.75 0 0 1 .728.568l.258 1.036c.236.94.97 1.674 1.91 1.91l1.036.258a.75.75 0 0 1 0 1.456l-1.036.258c-.94.236-1.674.97-1.91 1.91l-.258 1.036a.75.75 0 0 1-1.456 0l-.258-1.036a2.625 2.625 0 0 0-1.91-1.91l-1.036-.258a.75.75 0 0 1 0-1.456l1.036-.258a2.625 2.625 0 0 0 1.91-1.91l.258-1.036A.75.75 0 0 1 18 1.5ZM16.5 15a.75.75 0 0 1 .712.513l.394 1.183c.15.447.5.799.948.948l1.183.395a.75.75 0 0 1 0 1.422l-1.183.395c-.447.15-.799.5-.948.948l-.395 1.183a.75.75 0 0 1-1.422 0l-.395-1.183a1.5 1.5 0 0 0-.948-.948l-1.183-.395a.75.75 0 0 1 0-1.422l1.183-.395c.447-.15.799-.5.948-.948l.395-1.183A.75.75 0 0 1 16.5 15Z", clipRule: "evenodd" }) }), "Regenerate"] }) }) }), isLoading ? (_jsxs("div", { style: {
+                    }, label: triggerButtonText })), _jsx("div", { style: {
+                        position: 'relative',
+                        ...(isOpen && showTrigger && { top: 12 }),
+                    }, children: _jsx(PopoverComponent, { isOpen: isOpen, setIsOpen: (isOpen) => {
+                            if (!isOpen) {
+                                setShowUpdatePivot(false);
+                                setPopUpTitle('Add pivot');
+                            }
+                            setIsOpen(isOpen);
+                        }, popoverTitle: showUpdatePivot || !pivotRecommendationsEnabled
+                            ? popUpTitle
+                            : 'Recommended pivots', popoverChildren: _jsx("div", { style: {
+                                paddingTop: showUpdatePivot || !pivotRecommendationsEnabled ? 0 : 20,
+                                position: 'relative',
+                            }, children: showUpdatePivot || !pivotRecommendationsEnabled ? (_jsxs("div", { style: {
+                                    backgroundColor: 'rgb(255, 255, 255)',
+                                    display: 'flex',
+                                    flexDirection: 'column',
+                                    gap: 20,
+                                }, children: [isLoading && (_jsxs("div", { style: {
                                             background: theme.backgroundColor,
                                             width: 250,
                                             minWidth: 250,
@@ -395,7 +400,128 @@ export const PivotModal = ({ pivotRowField, setPivotRowField, pivotColumnField,
                                             display: 'flex',
                                             margin: '0px auto',
                                             justifyContent: 'center',
-                                        }, children: [_jsx("div", { style: { height: 100 } }), _jsxs("svg", { width: "24", height: "24", children: [_jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 6)", stroke: theme?.primaryTextColor || '#364153', fill: "none", transform: "rotate(-90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "-180 12 12", to: "180 12 12", dur: "0.8s", repeatCount: "indefinite" }) }), _jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 1 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", stroke: '#ADB1B9', fill: "none", transform: "rotate(90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "0 12 12", to: "360 12 12", dur: "0.8s", repeatCount: "indefinite" }) })] })] })) : (_jsx("div", { children: _jsx(PivotList, { recommendedPivotTables: recommendedPivotTables, createdPivotTables: createdPivotTables, theme: theme, onSelectRecommendedPivot: onSelectRecommendedPivot, onSelectCreatedPivot: onSelectCreatedPivot, selectedPivotIndex: selectedPivotIndex, selectedPivotType: selectedPivotType, ButtonComponent: ButtonComponent, HeaderComponent: HeaderComponent, onEditRecommendedPivot: onEditRecommendedPivot, onEditCreatedPivot: onEditPivot, showCreatePivot: true, showPivotEditButton: showPivotEditButton, LabelComponent: LabelComponent, TextComponent: TextComponent, CardComponent: CardComponent }) }))] })) })) }) })] }) }));
+                                        }, children: [_jsx("div", { style: { height: 100 } }), _jsxs("svg", { width: "24", height: "24", children: [_jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 6)", stroke: theme?.primaryTextColor || '#364153', fill: "none", transform: "rotate(-90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "-180 12 12", to: "180 12 12", dur: "0.8s", repeatCount: "indefinite" }) }), _jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 1 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", stroke: '#ADB1B9', fill: "none", transform: "rotate(90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "0 12 12", to: "360 12 12", dur: "0.8s", repeatCount: "indefinite" }) })] })] })), samplePivotTable && !isLoading && (_jsx("div", { style: {
+                                            width: pivotCardWidth,
+                                            minHeight: 160,
+                                        }, children: _jsx(PivotCard, { pivotTable: samplePivotTable, theme: theme, index: 0, selectedPivotIndex: -1, onEditPivot: () => { }, ButtonComponent: ButtonComponent, showEdit: false, clickable: false, minHeight: 140, LabelComponent: LabelComponent, TextComponent: TextComponent, HeaderComponent: HeaderComponent, CardComponent: CardComponent, onSelectPivot: () => { }, onClose: () => {
+                                                setPivotAggregation(null);
+                                                setPivotRowField(null);
+                                                setPivotValueField(null);
+                                                setPivotColumnField(null);
+                                                setSamplePivotTable(null);
+                                            } }) })), _jsxs(PivotColumnContainer, { children: [_jsxs(PivotRowContainer, { children: [_jsx("div", { ref: rowFieldRef, children: _jsx(SelectComponent, { id: "pivot-row-field", label: "Row field", value: pivotRowField, onChange: (e) => {
+                                                                pivotFieldChange('rowField', e.target.value);
+                                                                setPivotRowField(e.target.value === ''
+                                                                    ? undefined
+                                                                    : e.target.value);
+                                                            }, options: allowedRowFields.map((field) => {
+                                                                return {
+                                                                    label: snakeCaseToTitleCase(field),
+                                                                    value: field,
+                                                                };
+                                                            }), width: 200 }) }), _jsx("div", { ref: colFieldRef, children: _jsx(SelectComponent, { id: "pivot-row-field", label: "Column field", value: pivotColumnField, onChange: (e) => {
+                                                                pivotFieldChange('columnField', e.target.value);
+                                                                setPivotColumnField(e.target.value === ''
+                                                                    ? undefined
+                                                                    : e.target.value);
+                                                            }, options: allowedColumnFields.map((field) => {
+                                                                return {
+                                                                    label: snakeCaseToTitleCase(field),
+                                                                    value: field,
+                                                                };
+                                                            }), width: 200 }) })] }), _jsxs(PivotRowContainer, { children: [_jsx(SelectComponent, { id: "pivot-row-field", label: "Value field", value: pivotValueField, onChange: (e) => {
+                                                            pivotFieldChange('valueField', e.target.value);
+                                                            setPivotValueField(e.target.value === ''
+                                                                ? undefined
+                                                                : e.target.value);
+                                                        }, options: allowedValueFields.map((field) => {
+                                                            return {
+                                                                label: snakeCaseToTitleCase(field),
+                                                                value: field,
+                                                            };
+                                                        }), width: 200 }), _jsx(SelectComponent, { id: "pivot-row-field", label: "Aggregation type", value: pivotAggregation, onChange: (e) => {
+                                                            if (e.target.value !== 'count' &&
+                                                                pivotValueField &&
+                                                                !numberFormatOptions.includes(columns.find((col) => col.field === pivotValueField)?.format)) {
+                                                                setPivotValueField(null);
+                                                            }
+                                                            pivotFieldChange('aggregationType', e.target.value);
+                                                            setPivotAggregation(e.target.value === ''
+                                                                ? undefined
+                                                                : e.target.value);
+                                                        }, options: [
+                                                            ...['sum', 'average', 'count', 'max', 'min'].map((option) => {
+                                                                return { label: option, value: option };
+                                                            }),
+                                                        ], width: 200 })] })] }), _jsxs("div", { children: [_jsx(ButtonComponent, { id: "custom-button", onClick: () => {
+                                                    const errors = [];
+                                                    if (!pivotValueField &&
+                                                        pivotAggregation !== 'count') {
+                                                        errors.push("Value field cannot be empty when aggregation is not 'count'");
+                                                    }
+                                                    if (!pivotAggregation) {
+                                                        errors.push('Aggregation cannot be empty');
+                                                    }
+                                                    if (errors.length === 0) {
+                                                        const pivot = {
+                                                            rowField: pivotRowField || '',
+                                                            rowFieldType: columnsToShow[pivotRowField || ''],
+                                                            columnField: pivotColumnField,
+                                                            columnFieldType: columnsToShow[pivotColumnField || ''],
+                                                            valueField: pivotValueField || '',
+                                                            aggregationType: pivotAggregation || '',
+                                                        };
+                                                        pivot.title = generatePivotTitle(pivot);
+                                                        setIsOpen(false);
+                                                        setCreatedPivots([pivot]);
+                                                        onSelectCreatedPivot(pivot, 0);
+                                                        setPopUpTitle('Add pivot');
+                                                    }
+                                                    setErrors(errors);
+                                                }, label: popUpTitle }), errors.length > 0 && (_jsx("div", { style: {
+                                                    display: 'flex',
+                                                    flexDirection: 'column',
+                                                    gap: 8,
+                                                    paddingTop: 8,
+                                                    width: pivotCardWidth,
+                                                    maxWidth: pivotCardWidth,
+                                                }, children: errors.map((error, index) => (_jsx(ErrorMessageComponent, { errorMessage: error }, `error_message_${index}`))) }))] })] })) : (_jsx("div", { style: {
+                                    display: 'flex',
+                                    flexDirection: 'column',
+                                    fontFamily: theme?.fontFamily,
+                                    color: theme?.primaryTextColor,
+                                    width: selectedPivotTable ? 500 : 600,
+                                    maxHeight: 600,
+                                    overflowY: 'scroll',
+                                }, children: selectedPivotIndex >= 0 ? (_jsx("div", { children: _jsx("div", { onClick: () => {
+                                            setPopUpTitle('Edit pivot');
+                                            onEditPivot(createdPivots[0], 0);
+                                        }, children: _jsx(PivotCard, { pivotTable: {
+                                                pivot: selectedPivotTable?.pivot,
+                                                rows: selectedPivotTable?.rows,
+                                                columns: selectedPivotTable?.columns,
+                                            }, theme: theme, index: 0, onSelectPivot: () => { }, selectedPivotIndex: -1, onEditPivot: () => { }, ButtonComponent: ButtonComponent, showEdit: false, onClose: () => {
+                                                removePivot();
+                                            }, clickable: true, minHeight: 180, CardComponent: CardComponent, LabelComponent: LabelComponent, TextComponent: TextComponent, HeaderComponent: HeaderComponent }) }) })) : (_jsxs("div", { style: { display: 'flex', flexDirection: 'column' }, children: [_jsxs("div", { style: {
+                                                // position button inline with the popover title
+                                                position: 'absolute',
+                                                top: -36,
+                                                right: 0,
+                                                display: 'flex',
+                                                flexDirection: 'row',
+                                                gap: 8,
+                                            }, children: [_jsx(SecondaryButtonComponent, { label: "Regenerate", onClick: refreshPivots, icon: _jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", style: { width: 16, height: 16 }, children: _jsx("path", { fillRule: "evenodd", d: "M9 4.5a.75.75 0 0 1 .721.544l.813 2.846a3.75 3.75 0 0 0 2.576 2.576l2.846.813a.75.75 0 0 1 0 1.442l-2.846.813a3.75 3.75 0 0 0-2.576 2.576l-.813 2.846a.75.75 0 0 1-1.442 0l-.813-2.846a3.75 3.75 0 0 0-2.576-2.576l-2.846-.813a.75.75 0 0 1 0-1.442l2.846-.813A3.75 3.75 0 0 0 7.466 7.89l.813-2.846A.75.75 0 0 1 9 4.5ZM18 1.5a.75.75 0 0 1 .728.568l.258 1.036c.236.94.97 1.674 1.91 1.91l1.036.258a.75.75 0 0 1 0 1.456l-1.036.258c-.94.236-1.674.97-1.91 1.91l-.258 1.036a.75.75 0 0 1-1.456 0l-.258-1.036a2.625 2.625 0 0 0-1.91-1.91l-1.036-.258a.75.75 0 0 1 0-1.456l1.036-.258a2.625 2.625 0 0 0 1.91-1.91l.258-1.036A.75.75 0 0 1 18 1.5ZM16.5 15a.75.75 0 0 1 .712.513l.394 1.183c.15.447.5.799.948.948l1.183.395a.75.75 0 0 1 0 1.422l-1.183.395c-.447.15-.799.5-.948.948l-.395 1.183a.75.75 0 0 1-1.422 0l-.395-1.183a1.5 1.5 0 0 0-.948-.948l-1.183-.395a.75.75 0 0 1 0-1.422l1.183-.395c.447-.15.799-.5.948-.948l.395-1.183A.75.75 0 0 1 16.5 15Z", clipRule: "evenodd" }) }) }), _jsx(SecondaryButtonComponent, { label: "Create pivot +", onClick: () => onEditPivot({}, null) })] }), isLoading ? (_jsxs("div", { style: {
+                                                background: theme.backgroundColor,
+                                                width: 250,
+                                                minWidth: 250,
+                                                height: '100%',
+                                                paddingLeft: 20,
+                                                paddingRight: 30,
+                                                paddingTop: 40,
+                                                display: 'flex',
+                                                margin: '0px auto',
+                                                justifyContent: 'center',
+                                            }, children: [_jsx("div", { style: { height: 100 } }), _jsxs("svg", { width: "24", height: "24", children: [_jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 6)", stroke: theme?.primaryTextColor || '#364153', fill: "none", transform: "rotate(-90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "-180 12 12", to: "180 12 12", dur: "0.8s", repeatCount: "indefinite" }) }), _jsx("circle", { cx: "12", cy: "12", r: "9.375", strokeWidth: "3.75", strokeDasharray: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 1 / 3)", strokeDashoffset: "calc(2 * 3.14 * 9.375 / 3) calc(2 * 3.14 * 9.375 * 2 / 3)", stroke: '#ADB1B9', fill: "none", transform: "rotate(90 12 12)", children: _jsx("animateTransform", { attributeName: "transform", attributeType: "XML", type: "rotate", from: "0 12 12", to: "360 12 12", dur: "0.8s", repeatCount: "indefinite" }) })] })] })) : (_jsx("div", { children: _jsx(PivotList, { recommendedPivotTables: recommendedPivotTables, createdPivotTables: createdPivotTables, theme: theme, onSelectRecommendedPivot: onSelectRecommendedPivot, onSelectCreatedPivot: onSelectCreatedPivot, selectedPivotIndex: selectedPivotIndex, selectedPivotType: selectedPivotType, ButtonComponent: ButtonComponent, HeaderComponent: HeaderComponent, onEditRecommendedPivot: onEditRecommendedPivot, onEditCreatedPivot: onEditPivot, showPivotEditButton: showPivotEditButton, LabelComponent: LabelComponent, TextComponent: TextComponent, CardComponent: CardComponent }) }))] })) })) }) }) })] }) }));
 };
 export function generatePivotTableYAxis(pivot, cols, format) {
     // Use the column field for the field and label if there is one
@@ -404,12 +530,9 @@ export function generatePivotTableYAxis(pivot, cols, format) {
     }
     // For count aggregations, use 'count' for the label
     if (pivot?.aggregationType === 'count') {
-        return [{ field: pivot.valueField, label: 'count', format: format }];
-    }
-    // For average aggregations, use 'average <label>' for the label
-    if (pivot?.aggregationType === 'average') {
-        const label = `average ${pivot.valueField}`;
-        return [{ field: pivot.valueField, label, format: format }];
+        return [
+            { field: pivot.valueField || 'count', label: 'count', format: format },
+        ];
     }
     // otherwise use the default (ie. the field label)
     return [
@@ -420,7 +543,15 @@ export function generatePivotTableYAxis(pivot, cols, format) {
         },
     ];
 }
-function generatePivotTitle(pivot) {
+export function generatePivotTitle(pivot) {
+    if (pivot.rowField && !pivot.valueField) {
+        return snakeCaseToTitleCase(`${pivot.aggregationType} of ${pivot.rowField}
+      `);
+    }
+    else if (pivot.valueField && !pivot.rowField) {
+        return snakeCaseToTitleCase(`${pivot.aggregationType} of ${pivot.valueField}
+      `);
+    }
     return snakeCaseToTitleCase(`${pivot.aggregationType} of ${pivot.valueField} by ${pivot.rowField}${pivot.columnField ? ` and ${pivot.columnField}` : ''}`);
 }
 function castValueToDate(value) {
@@ -432,7 +563,17 @@ function castValueToDate(value) {
     }
     return new Date(value);
 }
+function getRecentDate(a, b) {
+    return a > b ? a : b;
+}
+function getEarliestDate(a, b) {
+    return a < b ? a : b;
+}
 function getDateRange(dateRange, column, data) {
+    const currentTime = new Date().getTime();
+    const ONE_CENTURY_IN_MILLISECONDS = 100 * 365 * 24 * 60 * 60 * 1000;
+    const maxDate = new Date(currentTime + ONE_CENTURY_IN_MILLISECONDS);
+    const minDate = new Date(0);
     if (!dateRange || !dateRange[0]) {
         if (data.length == 0 || !data[0][column]) {
             return { start: new Date(), end: new Date() };
@@ -449,12 +590,28 @@ function getDateRange(dateRange, column, data) {
         for (let i = 0; i < data.length; i++) {
             if (data[i][column]) {
                 const value = castValueToDate(data[i][column]);
-                lastestDate = lastestDate === null ? value : max([lastestDate, value]);
-                earliestDate =
-                    earliestDate === null ? value : min([earliestDate, value]);
+                if (lastestDate && lastestDate > minDate) {
+                    lastestDate = value;
+                }
+                if (value && value < maxDate) {
+                    lastestDate =
+                        lastestDate === null ? value : getRecentDate(lastestDate, value);
+                }
+                if (value && value > minDate) {
+                    if (earliestDate && earliestDate < minDate) {
+                        earliestDate = value;
+                    }
+                    earliestDate =
+                        earliestDate === null
+                            ? value
+                            : getEarliestDate(earliestDate, value);
+                }
             }
         }
-        return { start: earliestDate, end: lastestDate };
+        return {
+            start: earliestDate,
+            end: lastestDate,
+        };
     }
     else {
         return { start: dateRange[0], end: dateRange[1] };
@@ -511,6 +668,7 @@ function getDateString(value, dateRange) {
     return valueFormatter({
         value,
         field: 'date',
+        // @ts-ignore
         fields: [{ field: 'date', format }],
     });
 }
@@ -571,15 +729,12 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
     const uniqueRows = (isDateField(pivot.rowFieldType)
         ? getDateBuckets(dateRange, pivot.rowField, data)
         : [...new Set(data.map((item) => item[pivot.rowField]))]).filter((row) => Boolean(row));
-    const rowDateRange = pivot.rowField
-        ? getDateRange(dateRange, pivot.rowField, data)
-        : null;
-    const columnDateRange = pivot.columnField
-        ? getDateRange(dateRange, pivot.columnField, data)
-        : null;
+    const rowDateRange = getDateRange(dateRange, pivot.rowField, data);
+    const compRowDateRange = getDateRange(compRange ?? dateRange, pivot.rowField, data);
     // If columnField is not provided, we will not be using uniqueColumns
-    const uniqueColumns = (pivot.columnField && pivot.columnField.trim()
-        ? isDateField(pivot.columnFieldType)
+    // @ts-ignore
+    const uniqueColumns = (pivot.columnField
+        ? isDateField(pivot.columnFieldType || '')
             ? getDateBuckets(dateRange, pivot.columnField, data)
             : [...new Set(data.map((item) => item[pivot.columnField || '']))]
         : [pivot.valueField]).filter((col) => Boolean(col));
@@ -588,12 +743,11 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
     const ROW_DATE_MAP = {};
     // add in the comparison columns for all columns in the pivot
     let compUniqueRows = [];
-    let compRowDateRange = [];
     if (isComparison) {
         if (pivot.columnField) {
             const col = pivot.columnField;
             const row = pivot.rowField;
-            const isDateCol = isDateField(pivot.columnFieldType);
+            const isDateCol = isDateField(pivot.columnFieldType || '');
             const isDateRow = isDateField(pivot.rowFieldType);
             data.forEach((item) => {
                 if (isDateCol) {
@@ -617,9 +771,15 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
         compUniqueRows = (isDateField(pivot.rowFieldType)
             ? getCompDateBuckets(dateRange, compRange ?? dateRange, pivot.rowField, data)
             : [...new Set(data.map((item) => item[pivot.rowField]))]).filter((row) => Boolean(row));
-        compRowDateRange = pivot.rowField
-            ? getDateRange(compRange ?? dateRange, pivot.rowField, data)
-            : null;
+    }
+    // Special corner case for count with only rowField pivot
+    if (!pivot.valueField &&
+        !pivot.columnField &&
+        pivot.aggregationType === 'count') {
+        uniqueColumns.push('count');
+        if (isComparison) {
+            uniqueColumns.push('comparison_count');
+        }
     }
     const rowsToGenerate = rowLimit !== -1 && rowLimit <= uniqueRows.length
         ? uniqueRows.slice(0, rowLimit + 1)
@@ -642,18 +802,20 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
             let comparisonValue;
             let value;
             const nextRowValue = isDateField(pivot.rowFieldType)
-                ? uniqueRows[rowIndex + 1] ?? endOfDay(rowDateRange.end)
+                ? // @ts-ignore
+                    uniqueRows[rowIndex + 1] ?? endOfDay(rowDateRange.end)
                 : null;
             const compRowValue = compUniqueRows[rowIndex];
             const compNextRowValue = isDateField(pivot.rowFieldType)
                 ? compUniqueRows[rowIndex + 1] ?? endOfDay(compRowDateRange.end)
                 : null;
             if (pivot.columnField) {
-                const nextColumnValue = isDateField(pivot.columnFieldType)
+                const columnDateRange = getDateRange(dateRange, pivot.columnField, data);
+                const nextColumnValue = isDateField(pivot.columnFieldType || '')
                     ? uniqueColumns[colIndex + 1] || endOfDay(columnDateRange.end)
                     : null;
                 // If columnField is provided, filter by both rowField and columnField
-                if (isDateField(pivot.columnFieldType) &&
+                if (isDateField(pivot.columnFieldType || '') &&
                     isDateField(pivot.rowFieldType)) {
                     filteredData = data.filter((item) => {
                         return (isWithinInterval(new Date(item[pivot.rowField]), {
@@ -678,7 +840,7 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
                         });
                     }
                 }
-                else if (isDateField(pivot.columnFieldType) &&
+                else if (isDateField(pivot.columnFieldType || '') &&
                     !isDateField(pivot.rowFieldType)) {
                     filteredData = data.filter((item) => {
                         return (item[pivot.rowField] === rowValue &&
@@ -697,7 +859,7 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
                         });
                     }
                 }
-                else if (!isDateField(pivot.columnFieldType) &&
+                else if (!isDateField(pivot.columnFieldType || '') &&
                     isDateField(pivot.rowFieldType)) {
                     filteredData = data.filter((item) => {
                         return (isWithinInterval(new Date(item[pivot.rowField]), {
@@ -783,15 +945,15 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
                     }
                     break;
                 case 'max':
-                    value = filteredData.reduce((max, item) => Math.max(max, parseFloat(item[key] ?? 0)), -Infinity);
+                    value = filteredData.reduce((max, item) => Math.max(max, parseFloat(item[key] ?? -Infinity)), -Infinity);
                     if (isComparison) {
-                        comparisonValue = comparisonFilteredData.reduce((max, item) => Math.max(max, parseFloat(item[key] ?? 0)), -Infinity);
+                        comparisonValue = comparisonFilteredData.reduce((max, item) => Math.max(max, parseFloat(item[key] ?? -Infinity)), -Infinity);
                     }
                     break;
                 case 'min':
-                    value = filteredData.reduce((min, item) => Math.min(min, parseFloat(item[key] ?? 0)), Infinity);
+                    value = filteredData.reduce((min, item) => Math.min(min, parseFloat(item[key] ?? Infinity)), Infinity);
                     if (isComparison) {
-                        comparisonValue = comparisonFilteredData.reduce((min, item) => Math.min(min, parseFloat(item[key] ?? 0)), Infinity);
+                        comparisonValue = comparisonFilteredData.reduce((min, item) => Math.min(min, parseFloat(item[key] ?? Infinity)), Infinity);
                     }
                     break;
                 // Implement other aggregation types as needed
@@ -800,11 +962,11 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
             }
             // Set the value on the row
             // If columnField is not provided, colValue will be valueField
-            row[isDateField(pivot.columnFieldType)
+            row[isDateField(pivot.columnFieldType || '')
                 ? getDateString(colValue, dateRange)
                 : colValue] = pivot.aggregationType === 'count' ? value : value.toFixed(2);
             if (isComparison && pivot.columnField) {
-                if (isDateField(pivot.columnFieldType)) {
+                if (isDateField(pivot.columnFieldType || '')) {
                     row[`comparison_${getDateString(colValue, dateRange)}`] =
                         pivot.aggregationType === 'count'
                             ? comparisonValue
@@ -822,15 +984,11 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
     });
     const columns = [
         {
-            label: pivot.rowField === null
-                ? 'Null'
-                : pivot.rowField === false
-                    ? 'False'
-                    : snakeCaseToTitleCase(pivot.rowField),
+            label: pivot.rowField === null ? 'Null' : snakeCaseToTitleCase(pivot.rowField),
             field: pivot.rowField,
         },
         ...uniqueColumns.map((column, index) => {
-            const columnName = isDateField(pivot.columnFieldType)
+            const columnName = isDateField(pivot.columnFieldType || '')
                 ? getDateString(column, dateRange)
                 : column;
             return {
@@ -848,7 +1006,7 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
         }),
         ...(isComparison && pivot.columnField
             ? uniqueColumns.map((column, index) => {
-                const columnName = isDateField(pivot.columnFieldType)
+                const columnName = isDateField(pivot.columnFieldType || '')
                     ? getDateString(column, dateRange)
                     : column;
                 return {
@@ -860,10 +1018,10 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
                                 !pivot.columnField &&
                                 index === 1
                                 ? 'Comparison Count'
-                                : isDateField(pivot.columnFieldType)
+                                : isDateField(pivot.columnFieldType || '')
                                     ? COL_DATE_MAP[getDateString(column, dateRange)] ??
                                         'Comparison'
-                                    : `Comparison ${snakeCaseToTitleCase(columnName)}`,
+                                    : `comparison ${snakeCaseToTitleCase(columnName)}`,
                     field: `comparison_${columnName}`,
                 };
             })
@@ -872,22 +1030,24 @@ export function generatePivotTable(pivot, data, dateRange, isComparison, rowLimi
     if (pivot.sort) {
         pivotRows.sort((a, b) => {
             if (pivot.sortDirection === 'ASC') {
-                if (pivot.rowFieldType === 'date') {
-                    return new Date(a[pivot.rowField]) - new Date(b[pivot.rowField]);
+                if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                    // @ts-ignore
+                    return new Date(a[pivot.sortField]) - new Date(b[pivot.sortField]);
                 }
-                else if (isNumericColumnType(pivot.rowFieldType)) {
-                    return a[pivot.rowField] - b[pivot.rowField];
+                else if (isNumericColumnType(pivot.sortFieldType)) {
+                    return a[pivot.sortField] - b[pivot.sortField];
                 }
-                return a[pivot.rowField].localeCompare(b[pivot.rowField]);
+                return a[pivot.sortField].localeCompare(b[pivot.sortField]);
             }
             else {
-                if (pivot.rowFieldType === 'date') {
-                    return new Date(b[pivot.rowField]) - new Date(a[pivot.rowField]);
+                if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                    // @ts-ignore
+                    return new Date(b[pivot.sortField]) - new Date(a[pivot.sortField]);
                 }
-                else if (isNumericColumnType(pivot.rowFieldType)) {
-                    return a[pivot.rowField] - b[pivot.rowField];
+                else if (isNumericColumnType(pivot.sortFieldType)) {
+                    return b[pivot.sortField] - a[pivot.sortField];
                 }
-                return b[pivot.rowField].localeCompare(a[pivot.rowField]);
+                return b[pivot.sortField].localeCompare(a[pivot.sortField]);
             }
         });
     }
@@ -913,8 +1073,7 @@ function valueFieldAggregation(data, valueField, aggregationType, isComparison)
         case 'average':
             const count = data.reduce((count, item) => count + (item[valueField] ? 1 : 0), 0);
             value =
-                data.reduce((sum, item) => sum + parseFloat(item[valueField] ?? 0), 0) /
-                    (count === 0 ? 1 : count);
+                data.reduce((sum, item) => sum + parseFloat(item[valueField] ?? 0), 0) / (count === 0 ? 1 : count);
             if (isComparison) {
                 const comparisonCount = data.reduce((count, item) => count + (item[`comparison_${valueField}`] ? 1 : 0), 0);
                 comparisonValue =
@@ -922,15 +1081,15 @@ function valueFieldAggregation(data, valueField, aggregationType, isComparison)
             }
             break;
         case 'max':
-            value = data.reduce((max, item) => Math.max(max, parseFloat(item[valueField] ?? 0)), -Infinity);
+            value = data.reduce((max, item) => Math.max(max, parseFloat(item[valueField] ?? -Infinity)), -Infinity);
             if (isComparison) {
-                comparisonValue = data.reduce((max, item) => Math.max(max, parseFloat(item[`comparison_${valueField}`] ?? 0)), -Infinity);
+                comparisonValue = data.reduce((max, item) => Math.max(max, parseFloat(item[`comparison_${valueField}`] ?? -Infinity)), -Infinity);
             }
             break;
         case 'min':
-            value = data.reduce((min, item) => Math.min(min, parseFloat(item[valueField] ?? 0)), Infinity);
+            value = data.reduce((min, item) => Math.min(min, parseFloat(item[valueField] ?? Infinity)), Infinity);
             if (isComparison) {
-                comparisonValue = data.reduce((min, item) => Math.min(min, parseFloat(item[`comparison_${valueField}`] ?? 0)), Infinity);
+                comparisonValue = data.reduce((min, item) => Math.min(min, parseFloat(item[`comparison_${valueField}`] ?? Infinity)), Infinity);
             }
             break;
         // Implement other aggregation types as needed