@quillsql/react 2.12.37 → 2.12.39

package/dist/esm/contexts/SelectedValueContext.js

@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+const SelectedValueContext = createContext({
+    selectedValue: undefined,
+    handleValueChange: undefined,
+});
+export default SelectedValueContext;

package/dist/esm/contexts/index.d.ts

@@ -0,0 +1,5 @@
+export { default as BaseColorContext } from './BaseColorContext';
+export { default as HoveredValueContext } from './HoveredValueContext';
+export { default as RootStylesContext } from './RootStylesContext';
+export { default as SelectedValueContext } from './SelectedValueContext';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/contexts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contexts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/esm/contexts/index.js

@@ -0,0 +1,4 @@
+export { default as BaseColorContext } from './BaseColorContext';
+export { default as HoveredValueContext } from './HoveredValueContext';
+export { default as RootStylesContext } from './RootStylesContext';
+export { default as SelectedValueContext } from './SelectedValueContext';

package/dist/esm/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { default as useInternalState } from './useInternalState';
+export { default as useOnClickOutside } from './useOnClickOutside';
+export { default as useOnWindowResize } from './useOnWindowResize';
+export { default as useSelectOnKeyDown } from './useSelectOnKeyDown';
+export { default as useTheme } from './useTheme';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/esm/hooks/index.js

@@ -0,0 +1,5 @@
+export { default as useInternalState } from './useInternalState';
+export { default as useOnClickOutside } from './useOnClickOutside';
+export { default as useOnWindowResize } from './useOnWindowResize';
+export { default as useSelectOnKeyDown } from './useSelectOnKeyDown';
+export { default as useTheme } from './useTheme';

package/dist/esm/hooks/useAstToFilterTree.d.ts

@@ -0,0 +1,11 @@
+import { FilterTreeNode } from '../utils/astFilterProcessing';
+/**
+ * @param ast
+ * @param client
+ * @returns Filter tree
+ *
+ * Hook that takes in an ast where node and parses it into a filter tree
+ */
+declare const useAstToFilterTree: (ast: any, client: any) => FilterTreeNode | null;
+export default useAstToFilterTree;
+//# sourceMappingURL=useAstToFilterTree.d.ts.map

package/dist/esm/hooks/useAstToFilterTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAstToFilterTree.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAstToFilterTree.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAmB,MAAM,8BAA8B,CAAC;AAE/E;;;;;;GAMG;AACH,QAAA,MAAM,kBAAkB,QAAS,GAAG,UAAU,GAAG,0BAkBhD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/esm/hooks/useAstToFilterTree.js

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react';
+import { astToFilterTree } from '../utils/astFilterProcessing';
+/**
+ * @param ast
+ * @param client
+ * @returns Filter tree
+ *
+ * Hook that takes in an ast where node and parses it into a filter tree
+ */
+const useAstToFilterTree = (ast, client) => {
+    const [filterTree, setFilterTree] = useState(null);
+    useEffect(() => {
+        if (!ast || !client) {
+            return setFilterTree(null);
+        }
+        const fetchFilter = () => {
+            const filterPromise = astToFilterTree(ast, client.databaseType.toLowerCase());
+            setFilterTree(filterPromise);
+        };
+        fetchFilter();
+    }, [ast, client]);
+    return filterTree;
+};
+export default useAstToFilterTree;

package/dist/esm/hooks/useDashboard.d.ts

@@ -0,0 +1,7 @@
+export declare const useDashboard: (dashboardName: string) => {
+    data: any;
+    isLoading: boolean;
+    error: any;
+    reload: (overrideDashboardName?: string, fetchFromServer?: boolean) => Promise<void>;
+};
+//# sourceMappingURL=useDashboard.d.ts.map

package/dist/esm/hooks/useDashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDashboard.d.ts","sourceRoot":"","sources":["../../../src/hooks/useDashboard.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,kBAAmB,MAAM;;;;qCAYtB,MAAM;CAyEjC,CAAC"}

package/dist/esm/hooks/useDashboard.js

@@ -0,0 +1,69 @@
+import { useContext, useEffect, useState } from 'react';
+import { ClientContext, DashboardDataContext } from '../Context';
+import { getData } from '../utils/dataFetcher';
+export const useDashboard = (dashboardName) => {
+    const { dashboardData, dashboardDataDispatch } = useContext(DashboardDataContext);
+    // if (dashboardName === undefined || dashboardName === null) {
+    //   throw new Error('useDashboard requires a dashboard name parameter');
+    // }
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [data, setData] = useState(null);
+    const [client] = useContext(ClientContext);
+    const handleReload = async (overrideDashboardName, fetchFromServer = false) => {
+        await getDashboards(overrideDashboardName ?? dashboardName, fetchFromServer);
+    };
+    async function getDashboards(dashboardName, fetchFromServer = false) {
+        if (!fetchFromServer &&
+            dashboardData &&
+            dashboardData[dashboardName] &&
+            dashboardData[dashboardName].newQueries) {
+            setData(dashboardData[dashboardName]);
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        if (!client || !client.publicKey || !client.customerId) {
+            return;
+        }
+        if (dashboardName === null || dashboardName === undefined)
+            return;
+        const { databaseType, publicKey, customerId } = client;
+        try {
+            const searchParams = new URLSearchParams({
+                publicKey: publicKey,
+                orgId: customerId,
+                name: dashboardName,
+            }).toString();
+            const hostedBody = {
+                metadata: {
+                    name: dashboardName,
+                    task: 'config',
+                    clientId: publicKey,
+                    orgId: customerId || '*',
+                    databaseType: databaseType,
+                    useNewNodeSql: true,
+                },
+            };
+            const resp = await getData(client, `dashconfig?${searchParams}`, 'omit', hostedBody, null, 'GET');
+            dashboardDataDispatch({
+                type: 'ADD_DASHBOARD',
+                id: dashboardName,
+                data: { ...resp },
+            });
+            setData(resp);
+            setIsLoading(false);
+            setError(null);
+        }
+        catch (error) {
+            setError(null);
+            setIsLoading(false);
+            setError(error);
+            console.error('Error fetching data:', error);
+        }
+    }
+    useEffect(() => {
+        getDashboards(dashboardName, true);
+    }, [dashboardName, client]);
+    return { data, isLoading, error, reload: handleReload };
+};

package/dist/esm/hooks/useExport.d.ts

@@ -0,0 +1,6 @@
+export declare const useExport: (reportId?: string) => {
+    downloadCSV: () => void;
+    downloadPDF: () => void;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useExport.d.ts.map

package/dist/esm/hooks/useExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExport.d.ts","sourceRoot":"","sources":["../../../src/hooks/useExport.tsx"],"names":[],"mappings":"AA0DA,eAAO,MAAM,SAAS,cAAe,MAAM;;;;CAuC1C,CAAC"}

package/dist/esm/hooks/useExport.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { downloadCSV } from '../utils/csv';
+import { useContext, useLayoutEffect, useRef, useState } from 'react';
+import { getData } from '../utils/dataFetcher';
+import { ClientContext, DashboardFiltersContext } from '../Context';
+import ReactDOM from 'react-dom';
+import useTheme from './useTheme';
+import { quillFormat } from '../utils/valueFormatter';
+import { cleanDashboardItem } from '../utils/dashboard';
+import { useReactToPrint } from 'react-to-print';
+import { ChartDisplay } from '../Chart';
+async function getExportData(client, dashboardFilters, reportId) {
+    const minimalFilters = Object.values(dashboardFilters).length
+        ? Object.values(dashboardFilters).map((filter) => {
+            const newFilter = { ...filter };
+            if (newFilter.filterType === 'date_range') {
+                delete newFilter['field'];
+                delete newFilter['options'];
+                delete newFilter['selectedValue'];
+            }
+            return newFilter;
+        })
+        : [];
+    const hostedBody = {
+        metadata: {
+            dashboardItemId: reportId,
+            orgId: client.customerId || '*',
+            clientId: client.publicKey,
+            task: 'item',
+            databaseType: client?.databaseType,
+            filters: minimalFilters,
+            useNewNodeSql: true,
+        },
+    };
+    const cloudBody = {
+        id: reportId,
+        useNewNodeSql: true,
+    };
+    const resp = await getData(client, 'itempost', 'same-origin', hostedBody, cloudBody);
+    const cleanedReport = await cleanDashboardItem(resp, dashboardFilters);
+    if (cleanedReport.chartType === 'table' && cleanedReport.pivot) {
+        cleanedReport.columns = cleanedReport.yAxisFields;
+    }
+    return cleanedReport;
+}
+export const useExport = (reportId) => {
+    const { dashboardFilters } = useContext(DashboardFiltersContext);
+    const theme = useTheme();
+    const [client] = useContext(ClientContext);
+    const [isLoading, setIsLoading] = useState(false);
+    if (!reportId) {
+        return { downloadCSV: () => { }, downloadPDF: () => { }, isLoading: false };
+    }
+    return {
+        downloadCSV: async () => {
+            setIsLoading(true);
+            const resp = await getExportData(client, dashboardFilters, reportId);
+            downloadCSV({
+                rows: resp.rows,
+                fields: resp.columns,
+                name: resp.name,
+            });
+            setIsLoading(false);
+        },
+        downloadPDF: async () => {
+            setIsLoading(true);
+            const resp = await getExportData(client, dashboardFilters, reportId);
+            const iframe = document.createElement('iframe');
+            document.body.appendChild(iframe);
+            if (iframe && iframe.contentDocument) {
+                ReactDOM.render(_jsx(PDFDetail, { report: resp, theme: theme }), iframe.contentDocument.body);
+            }
+            // delete the iframe
+            setTimeout(() => {
+                document.body.removeChild(iframe);
+            }, 1000);
+            setIsLoading(false);
+        },
+        isLoading,
+    };
+};
+function PDFDetail({ report, theme }) {
+    const componentRef = useRef(null);
+    const handlePrint = useReactToPrint({
+        content: () => componentRef.current,
+        pageStyle: `@page {
+      size: letter;
+      margin: 0;
+    }
+  
+    body {
+      margin: 2rem;
+    }`,
+    });
+    useLayoutEffect(() => {
+        setTimeout(() => handlePrint(), 1500);
+    }, []);
+    return (_jsxs("div", { ref: componentRef, style: { display: 'flex', flexDirection: 'column', margin: '2rem' }, children: [_jsx("div", { style: { display: 'flex', flexDirection: 'row', alignItems: 'center' }, children: _jsx("h2", { style: {
+                        fontSize: 18,
+                        fontWeight: '600',
+                        textAlign: 'left',
+                        paddingLeft: 10,
+                        color: theme?.primaryTextColor,
+                    }, children: report.name }) }), _jsxs("div", { style: { paddingLeft: 20, paddingRight: 20 }, children: [report.chartType !== 'table' && (_jsx(ChartDisplay, { overrideTheme: theme, config: report, containerStyle: {
+                            display: 'flex',
+                            height: 400,
+                        }, loading: false, isAnimationActive: false })), _jsx("div", { style: {
+                            border: '1px solid',
+                            borderRadius: '4px',
+                            borderStyle: 'none',
+                        }, children: _jsxs("table", { style: {
+                                fontFamily: 'sans-serif',
+                                width: '100%',
+                                borderCollapse: 'collapse',
+                                borderStyle: 'none',
+                            }, children: [_jsx("thead", { style: {
+                                        textAlign: 'left',
+                                        textOverflow: 'ellipsis',
+                                        whiteSpace: 'nowrap',
+                                        overflow: 'hidden',
+                                    }, children: _jsx("tr", { children: report.columns.map((col, colIndex) => (_jsx("th", { style: { padding: '2px', paddingLeft: '3px' }, children: col.label }, 'head' + colIndex))) }) }), _jsx("tbody", { children: report.rows.map((row, rowIndex) => (_jsx("tr", { children: report.columns.map((col, colIndex) => (_jsx("td", { style: { padding: '2px', paddingLeft: '3px' }, children: quillFormat({
+                                                value: row[col.field],
+                                                format: col.format,
+                                            }) }, 'cell' + col.field + colIndex + rowIndex))) }, 'row' + rowIndex))) })] }) })] })] }));
+}

package/dist/esm/hooks/useFormat.d.ts

@@ -0,0 +1,5 @@
+export declare const useMemoizedRows: (reportId: string) => {
+    rows: any[];
+    loading: boolean;
+};
+//# sourceMappingURL=useFormat.d.ts.map

package/dist/esm/hooks/useFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormat.d.ts","sourceRoot":"","sources":["../../../src/hooks/useFormat.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,aAChB,MAAM,KACf;IAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAwBjC,CAAC"}

package/dist/esm/hooks/useFormat.js

@@ -0,0 +1,25 @@
+import { quillFormat } from '../utils/valueFormatter';
+import { useQuill } from './useQuill';
+import { useMemo } from 'react';
+export const useMemoizedRows = (reportId) => {
+    const { data } = useQuill(reportId);
+    const formattedRows = useMemo(() => {
+        if (!data || !data.rows || !data.columns)
+            return { rows: [], loading: true };
+        return {
+            rows: data.rows.map((row) => {
+                return data.columns.reduce((formattedRow, column) => {
+                    // Apply the format function to each field in the row
+                    const formattedValue = quillFormat({
+                        value: row[column.field],
+                        format: column.format,
+                    });
+                    formattedRow[column.field] = formattedValue;
+                    return formattedRow;
+                }, {});
+            }),
+            loading: false,
+        };
+    }, [data]);
+    return formattedRows;
+};

package/dist/esm/hooks/useInternalState.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+declare const useInternalState: <T>(defaultValueProp: T, valueProp: T) => [T, import("react").Dispatch<import("react").SetStateAction<T>>];
+export default useInternalState;
+//# sourceMappingURL=useInternalState.d.ts.map

package/dist/esm/hooks/useInternalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInternalState.d.ts","sourceRoot":"","sources":["../../../src/hooks/useInternalState.tsx"],"names":[],"mappings":";AAEA,QAAA,MAAM,gBAAgB,4GAWrB,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/esm/hooks/useInternalState.js

@@ -0,0 +1,14 @@
+import { useState } from 'react';
+const useInternalState = (defaultValueProp, valueProp) => {
+    const isControlled = valueProp !== undefined;
+    const [valueState, setValueState] = useState(defaultValueProp);
+    const value = isControlled ? valueProp : valueState;
+    const setValue = (nextValue) => {
+        if (isControlled) {
+            return;
+        }
+        setValueState(nextValue);
+    };
+    return [value, setValue];
+};
+export default useInternalState;

package/dist/esm/hooks/useOnClickOutside.d.ts

@@ -0,0 +1,3 @@
+declare const useOnClickOutside: (ref: React.RefObject<HTMLDivElement>, handler: (event: any) => void) => void;
+export default useOnClickOutside;
+//# sourceMappingURL=useOnClickOutside.d.ts.map

package/dist/esm/hooks/useOnClickOutside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnClickOutside.d.ts","sourceRoot":"","sources":["../../../src/hooks/useOnClickOutside.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,iBAAiB,QAChB,MAAM,SAAS,CAAC,cAAc,CAAC,mBACjB,GAAG,KAAG,IAAI,SAgB9B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/esm/hooks/useOnClickOutside.js

@@ -0,0 +1,18 @@
+import { useEffect } from 'react';
+const useOnClickOutside = (ref, handler) => {
+    useEffect(() => {
+        const listener = (event) => {
+            if (!ref.current || ref.current.contains(event.target)) {
+                return;
+            }
+            handler(event);
+        };
+        document.addEventListener('mousedown', listener);
+        document.addEventListener('touchstart', listener);
+        return () => {
+            document.removeEventListener('mousedown', listener);
+            document.removeEventListener('touchstart', listener);
+        };
+    }, [ref, handler]);
+};
+export default useOnClickOutside;

package/dist/esm/hooks/useOnWindowResize.d.ts

@@ -0,0 +1,5 @@
+declare const useOnWindowResize: (handler: {
+    (): void;
+}, initialWindowSize?: number) => void;
+export default useOnWindowResize;
+//# sourceMappingURL=useOnWindowResize.d.ts.map

package/dist/esm/hooks/useOnWindowResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnWindowResize.d.ts","sourceRoot":"","sources":["../../../src/hooks/useOnWindowResize.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,iBAAiB,YACZ;IAAE,IAAI,IAAI,CAAA;CAAE,sBACD,MAAM,SAe3B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/esm/hooks/useOnWindowResize.js

@@ -0,0 +1,14 @@
+import { useEffect, useState } from 'react';
+const useOnWindowResize = (handler, initialWindowSize) => {
+    const [windowSize, setWindowSize] = useState(initialWindowSize);
+    useEffect(() => {
+        const handleResize = () => {
+            setWindowSize(window.innerWidth);
+            handler();
+        };
+        handleResize();
+        window.addEventListener('resize', handleResize);
+        return () => window.removeEventListener('resize', handleResize);
+    }, [handler, windowSize]);
+};
+export default useOnWindowResize;

package/dist/esm/hooks/useQuill.d.ts

@@ -0,0 +1,37 @@
+import { QuillReport } from '../models/Report';
+import { Calculation } from '../utils/dataProcessing';
+interface Column {
+    _id: string;
+    label: string;
+    field: string;
+    format: string;
+}
+export interface Field {
+    name: string;
+    tableID: number;
+    columnID: number;
+    dataTypeID: number;
+    dataTypeSize: number;
+    dataTypeModifier: number;
+    format: string;
+}
+export declare const useQuill: (reportId?: string, pagination?: {
+    rowsPerPage: number;
+    rowsPerRequest: number;
+}) => {
+    data: QuillReport | null;
+    loading: boolean;
+    error: string | undefined;
+    fetchMore: (page: number) => void;
+    setSort: (field: string, direction: string) => void;
+    calculate: ((calcType: Calculation) => number | undefined) | (() => undefined);
+};
+export declare const usePivot: (reportId?: string) => {
+    data: {
+        rows: any[];
+        columns: Column[];
+    } | undefined;
+    error: string | undefined;
+};
+export {};
+//# sourceMappingURL=useQuill.d.ts.map

package/dist/esm/hooks/useQuill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuill.d.ts","sourceRoot":"","sources":["../../../src/hooks/useQuill.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,WAAW,EAIZ,MAAM,yBAAyB,CAAC;AAEjC,UAAU,MAAM;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,QAAQ,cACR,MAAM,eACJ;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE;UAEtD,WAAW,GAAG,IAAI;aACf,OAAO;WACT,MAAM,GAAG,SAAS;sBACP,MAAM,KAAK,IAAI;qBAChB,MAAM,aAAa,MAAM,KAAK,IAAI;2BAEnC,WAAW,KAAK,MAAM,GAAG,SAAS,WACvC,SAAS;CAoLrB,CAAC;AAEF,eAAO,MAAM,QAAQ,cACR,MAAM;UAEX;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,SAAS;WAC7C,MAAM,GAAG,SAAS;CAoD1B,CAAC"}

package/dist/esm/hooks/useQuill.js

@@ -0,0 +1,182 @@
+import { useContext, useEffect, useState } from 'react';
+import { ClientContext, CustomFieldContext, DashboardContext, DashboardFiltersContext, } from '../Context';
+import { mergeComparisonRange } from '../utils/merge';
+import { fetchReport } from '../utils/report';
+import { shouldFetchMore } from '../utils/paginationProcessing';
+import { fetchTableByReport, } from '../utils/tableProcessing';
+import { getPointToPointPercentageChange, getSimplePercentageChange, getSumOfFields, } from '../utils/dataProcessing';
+export const useQuill = (reportId, pagination) => {
+    const [dashboard, dispatch] = useContext(DashboardContext);
+    const { dashboardFilters } = useContext(DashboardFiltersContext);
+    const [customFields] = useContext(CustomFieldContext);
+    const [client] = useContext(ClientContext);
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(undefined);
+    const [previousPage, setPreviousPage] = useState(0);
+    const [calculate, setCalculate] = useState(() => emptyCalculate);
+    function emptyCalculate() {
+        return undefined;
+    }
+    const [additionalProcessing, setAdditionProcessing] = useState(pagination
+        ? {
+            page: pagination,
+        }
+        : undefined);
+    function calculateFunction(calcType, options) {
+        if (!data) {
+            return undefined;
+        }
+        switch (calcType) {
+            case 'SIMPLE_PERCENTAGE_CHANGE':
+                return getSimplePercentageChange(data);
+            case 'POINT_TO_POINT_PERCENTAGE_CHANGE':
+                return getPointToPointPercentageChange(data);
+            case 'SUM':
+                return getSumOfFields(data, options?.comparison ? true : false);
+            default:
+                return getSimplePercentageChange(data);
+        }
+    }
+    const fetchMore = (page) => {
+        if (additionalProcessing &&
+            additionalProcessing.page &&
+            shouldFetchMore(additionalProcessing.page, page, previousPage)) {
+            const newPagination = { ...additionalProcessing.page, page };
+            const updatedProcessing = {
+                ...additionalProcessing,
+                page: newPagination,
+            };
+            setAdditionProcessing(updatedProcessing);
+            updateTableRows(updatedProcessing);
+        }
+        if (page > previousPage) {
+            setPreviousPage(page);
+        }
+    };
+    const setSort = (field, direction) => {
+        if (!additionalProcessing?.page) {
+            return;
+        }
+        const updatedProcessing = {
+            page: { ...additionalProcessing.page, page: 0 },
+            sort: { field, direction },
+        };
+        updateTableRows(updatedProcessing, true);
+        setAdditionProcessing(updatedProcessing);
+        setPreviousPage(0);
+    };
+    const updateTableRows = async (processing, resetRows = false) => {
+        if (!loading && reportId && data) {
+            setLoading(true);
+            try {
+                const specificDashboardFilter = dashboardFilters.filter((f) => f &&
+                    reportId &&
+                    dashboard[reportId] &&
+                    // @ts-ignore
+                    dashboard[reportId].dashboardName === f.dashboardName);
+                const updatedProcessing = { ...additionalProcessing, ...processing };
+                const paginatedRows = await fetchTableByReport(reportId, client, updatedProcessing, specificDashboardFilter, customFields);
+                if (paginatedRows.error) {
+                    throw new Error('Error fetching chart');
+                }
+                let tempRows = [...data.rows, ...paginatedRows.rows];
+                if (resetRows) {
+                    tempRows = paginatedRows.rows;
+                }
+                setData({ ...data, rows: tempRows });
+                setTimeout(() => {
+                    setLoading(false);
+                }, 200);
+            }
+            catch (e) {
+                console.log(e);
+                setLoading(false);
+            }
+        }
+    };
+    const fetchReportHelper = async (curReportId, useReportTask = true, additionalProcessing) => {
+        if (dashboard && dashboard[curReportId]) {
+            // @ts-ignore
+            if (dashboard[curReportId].compareRows) {
+                mergeComparisonRange(dashboard[curReportId]);
+            }
+            // @ts-ignore
+            setData({ ...dashboard[curReportId] });
+            setLoading(false);
+            return;
+        }
+        const specificDashboardFilter = dashboardFilters.filter((f) => f &&
+            reportId &&
+            dashboard[curReportId] &&
+            // @ts-ignore
+            dashboard[curReportId].dashboardName === f.dashboardName);
+        setLoading(true);
+        const { report, error } = await fetchReport(curReportId, client, useReportTask, specificDashboardFilter, additionalProcessing, undefined, customFields);
+        dispatch({
+            type: 'UPDATE_DASHBOARD_ITEM',
+            id: reportId,
+            data: {
+                ...report,
+                filtersApplied: specificDashboardFilter,
+                triggerReload: false,
+            },
+        });
+        setData(report);
+        setError(error);
+        setLoading(false);
+    };
+    useEffect(() => {
+        if (reportId) {
+            fetchReportHelper(reportId, pagination ? true : false, pagination);
+        }
+    }, [reportId, dashboard]);
+    useEffect(() => {
+        setCalculate(() => calculateFunction);
+    }, [data]);
+    return { data, loading, error, fetchMore, setSort, calculate };
+};
+export const usePivot = (reportId) => {
+    const [dashboard] = useContext(DashboardContext);
+    const [data, setData] = useState(undefined);
+    const [error, setError] = useState(undefined);
+    useEffect(() => {
+        if (!reportId ||
+            !dashboard ||
+            // @ts-ignore
+            !dashboard[reportId] ||
+            // @ts-ignore
+            !dashboard[reportId].pivotColumns ||
+            // @ts-ignore
+            !dashboard[reportId].pivotRows) {
+            setError('No data found');
+            return;
+        }
+        setData({
+            // @ts-ignore
+            rows: dashboard[reportId].pivotRows,
+            // @ts-ignore
+            columns: dashboard[reportId].pivotColumns
+                .map((col, index) => {
+                if (index === 0) {
+                    return {
+                        ...col,
+                        format: 'string',
+                    };
+                }
+                return {
+                    ...col,
+                    // @ts-ignore
+                    format: dashboard[reportId].yAxisFields[0].format,
+                };
+            })
+                .filter(
+            // @ts-ignore
+            (col) => 
+            // @ts-ignore
+            dashboard[reportId].chartType !== 'table' ||
+                !col.field.startsWith('comparison_')),
+        });
+    }, [dashboard, reportId]);
+    return { data, error };
+};

package/dist/esm/hooks/useSelectOnKeyDown.d.ts

@@ -0,0 +1,3 @@
+declare const useSelectOnKeyDown: (onValueChange: (value: string) => void, optionValues: string[], isFocused: boolean, handleFocusChange: (isFocused: boolean) => void, value?: string) => [string | null | undefined, (e: React.KeyboardEvent<HTMLDivElement | HTMLButtonElement>) => void];
+export default useSelectOnKeyDown;
+//# sourceMappingURL=useSelectOnKeyDown.d.ts.map

package/dist/esm/hooks/useSelectOnKeyDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelectOnKeyDown.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSelectOnKeyDown.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,kBAAkB,0BACC,MAAM,KAAK,IAAI,gBACxB,MAAM,EAAE,aACX,OAAO,iCACa,OAAO,KAAK,IAAI,UACvC,MAAM,qCAGV,mBAAmB,CAAC,cAAc,GAAG,iBAAiB,CAAC,KAAK,IAAI,CAqErE,CAAC;AAEF,eAAe,kBAAkB,CAAC"}