@quillsql/react 2.12.35 → 2.12.37

package/dist/esm/utils/monacoConfig.js

@@ -1,319 +0,0 @@
-import { processColumnReference } from './queryConstructor';
-export const QUILL_LANGUAGE = {
-    monarchTokensProvider: {
-        defaultToken: '',
-        tokenPostfix: '.pgsql',
-        keywords: [
-            'SELECT',
-            'select',
-            'FROM',
-            'fromt',
-            'WHERE',
-            'where',
-            'IF',
-            'if',
-            'THEN',
-            'then',
-            'ELSE',
-            'ELSIF',
-            'CASE',
-            'case',
-            'WHEN',
-            'when',
-            'NULL',
-            'null',
-            'TRUE',
-            'true',
-            'FALSE',
-            'false',
-            'AS',
-            'as',
-            'LEFT',
-            'left',
-            'INNER',
-            'inner',
-            'JOIN',
-            'join',
-        ],
-        operators: [
-            '=',
-            '<',
-            '>',
-            '<=',
-            '>=',
-            '<>',
-            '!=',
-            '!',
-            '&&',
-            '||',
-            '++',
-            '--',
-            '+',
-            '-',
-            '*',
-            '/',
-            '%',
-            '<<',
-            '>>',
-            '&',
-            '|',
-            '^',
-            '~',
-            '::',
-        ],
-        symbols: '[=><!~?:&|+\\-*\\/\\^%]+',
-        tokenizer: {
-            root: [
-                [
-                    /[a-zA-Z_$][\w$]*/,
-                    {
-                        cases: {
-                            '@keywords': 'keyword',
-                            '@default': 'identifier',
-                        },
-                    },
-                ],
-                { include: '@whitespace' },
-                ['[{}()\\[\\]]', '@brackets'],
-                ['[<>](?!@symbols)', '@brackets'],
-                [
-                    '@symbols',
-                    {
-                        cases: {
-                            '@operators': 'operator',
-                            '@default': '',
-                        },
-                    },
-                ],
-                ['\\d*\\.\\d+([eE][\\-+]?\\d+)?', 'number.float'],
-                ['\\d+', 'number'],
-                ['[;,.]', 'delimiter'],
-                ["'([^'\\\\]|\\\\.)*$", 'string.invalid'],
-                ["'", 'string', '@string'],
-            ],
-            whitespace: [
-                ['[ \\t\\r\\n]+', ''],
-                ['--.*$', 'comment'],
-                ['\\/\\*', 'comment', '@comment'],
-            ],
-            comment: [
-                ['[^\\/*]+', 'comment'],
-                ['\\*\\/', 'comment', '@pop'],
-                ['[\\/*]', 'comment'],
-            ],
-            string: [
-                ["[^\\\\']+", 'string'],
-                ['\\\\.', 'string.escape'],
-                ["'", 'string', '@pop'],
-                ['"[^\\\\"]*"', 'string'],
-                ['"', 'string', '@dblString'],
-            ],
-            dblString: [
-                ['[^\\\\"]+', 'string'],
-                ['\\\\.', 'string.escape'],
-                ['"', 'string', '@pop'],
-            ],
-        },
-    },
-    languageConfiguration: {
-        comments: {
-            lineComment: '--',
-            blockComment: ['/*', '*/'],
-        },
-        brackets: [
-            ['{', '}'],
-            ['[', ']'],
-            ['(', ')'],
-        ],
-        autoClosingPairs: [
-            { open: '{', close: '}' },
-            { open: '[', close: ']' },
-            { open: '(', close: ')' },
-            { open: "'", close: "'" },
-        ],
-        surroundingPairs: [
-            { open: '{', close: '}' },
-            { open: '[', close: ']' },
-            { open: '(', close: ')' },
-            { open: '"', close: '"' },
-            { open: "'", close: "'" },
-        ],
-    },
-};
-const GENERIC_DATASOURCE_SUGGESTIONS = (monaco, range) => {
-    return [
-        {
-            label: 'SELECT',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'SELECT',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'FROM',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'FROM',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'JOIN',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'JOIN',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'LEFT JOIN',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'LEFT JOIN',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'INNER JOIN',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'INNER JOIN',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'MAX',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'MAX',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'MIN',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'MIN',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'ON',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'ON',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'WHERE',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'WHERE',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'LIMIT',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'LIMIT',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'GROUP BY',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'GROUP BY',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'ORDER BY',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'ORDER BY',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-    ];
-};
-const POSTGRES_DATASOURCE_SUGGESTIONS = (monaco, range) => {
-    return [
-        {
-            label: 'EXTRACT',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'EXTRACT',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'TO_TIMESTAMP',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'TO_TIMESTAMP',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'CURRENT_DATE',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'CURRENT_DATE',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-        {
-            label: 'CURRENT_TIMESTAMP',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'CURRENT_TIMESTAMP',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-    ];
-};
-const BIGQUERY_DATASOURCE_SUGGESTIONS = (monaco, range) => {
-    return [
-        {
-            label: 'TO_TIMESTAMP',
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: 'TO_TIMESTAMP',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        },
-    ];
-};
-export function generateSuggestionsBySchema(schema, monaco, range, databaseType) {
-    const suggestions = [];
-    schema.forEach((table) => {
-        const curSuggestion = {
-            label: table.name,
-            kind: monaco.languages.CompletionItemKind.Field,
-            insertText: `${processColumnReference(table.name, databaseType).replaceAll('`', '')}`,
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            range,
-        };
-        suggestions.push(curSuggestion);
-        table.columns.forEach((column) => {
-            const insertText = `${processColumnReference(column.name, databaseType).replaceAll('`', '')}`;
-            const curSuggestion = {
-                label: column.name,
-                kind: monaco.languages.CompletionItemKind.Field,
-                insertText,
-                detail: table.name,
-                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-                range,
-            };
-            suggestions.push(curSuggestion);
-        });
-    }, []);
-    return suggestions;
-}
-export function generateSuggestionsByDatasource(monaco, range, databaseType) {
-    if (!databaseType) {
-        return GENERIC_DATASOURCE_SUGGESTIONS(monaco, range);
-    }
-    switch (databaseType.toLowerCase()) {
-        case 'snowflake':
-        case 'postgresql':
-            return [
-                ...POSTGRES_DATASOURCE_SUGGESTIONS(monaco, range),
-                ...GENERIC_DATASOURCE_SUGGESTIONS(monaco, range),
-            ];
-        case 'bigquery':
-            return [
-                ...BIGQUERY_DATASOURCE_SUGGESTIONS(monaco, range),
-                ...GENERIC_DATASOURCE_SUGGESTIONS(monaco, range),
-            ];
-        default:
-            return GENERIC_DATASOURCE_SUGGESTIONS(monaco, range);
-    }
-}

package/dist/esm/utils/paginationProcessing.d.ts

@@ -1,5 +0,0 @@
-import { Pagination } from '../models/Pagination';
-export declare const DEFAULT_PAGINATION: Pagination;
-export declare function shouldFetchMore(pagination: Pagination, page: number, maxPage: number): boolean;
-export declare function shouldSortInMemory(pagination: Pagination, rowCount?: number, isPivot?: boolean): boolean;
-//# sourceMappingURL=paginationProcessing.d.ts.map

package/dist/esm/utils/paginationProcessing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paginationProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/paginationProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,UAIhC,CAAC;AAEF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,WAehB;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,WASlB"}

package/dist/esm/utils/paginationProcessing.js

@@ -1,25 +0,0 @@
-export const DEFAULT_PAGINATION = {
-    page: 0,
-    rowsPerPage: 20,
-    rowsPerRequest: 500,
-};
-export function shouldFetchMore(pagination, page, maxPage) {
-    if (!pagination) {
-        return false;
-    }
-    const indexAdjustedPage = page;
-    const pageInterval = Math.floor((indexAdjustedPage * pagination.rowsPerPage) / pagination.rowsPerRequest);
-    const indexAdjustedPreviousPage = maxPage;
-    const previousPageInterval = Math.floor((indexAdjustedPreviousPage * pagination.rowsPerPage) /
-        pagination.rowsPerRequest);
-    return pageInterval > previousPageInterval;
-}
-export function shouldSortInMemory(pagination, rowCount, isPivot) {
-    if (isPivot) {
-        return true;
-    }
-    if (!rowCount || rowCount < pagination.rowsPerRequest) {
-        return true;
-    }
-    return false;
-}

package/dist/esm/utils/parserBigQuery.d.ts

@@ -1,6 +0,0 @@
-export declare const isInTheLastIntervalBigQuery: (node: any) => boolean;
-export declare const isAfterBigQuery: (node: any) => boolean;
-export declare const isBeforeBigQuery: (node: any) => boolean;
-export declare const isTheCurrentIntervalBigQuery: (node: any) => boolean;
-export declare const isEqualsBigQuery: (node: any) => any;
-//# sourceMappingURL=parserBigQuery.d.ts.map

package/dist/esm/utils/parserBigQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parserBigQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/parserBigQuery.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,SAAU,GAAG,YAYpD,CAAC;AAEF,eAAO,MAAM,eAAe,SAAU,GAAG,YAUxC,CAAC;AAEF,eAAO,MAAM,gBAAgB,SAAU,GAAG,YAUzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,SAAU,GAAG,KAAG,OAUxD,CAAC;AAEF,eAAO,MAAM,gBAAgB,SAAU,GAAG,QASzC,CAAC"}

package/dist/esm/utils/parserBigQuery.js

@@ -1,52 +0,0 @@
-// Functions use to parse BigQuery SQL
-export const isInTheLastIntervalBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'timestamp_sub' &&
-        node.right.args.value[0].type === 'function' &&
-        node.right.args.value[1].type === 'interval' &&
-        ['current_timestamp'].includes(node.right.args.value[0].name.toLowerCase());
-    return isOutsideOfDateTrunc;
-};
-export const isAfterBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        ((node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'timestamp') ||
-            node.right.type === 'timestamp');
-    return isOutsideOfDateTrunc;
-};
-export const isBeforeBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['<=', '<'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        ((node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'timestamp') ||
-            node.right.type === 'timestamp');
-    return isOutsideOfDateTrunc;
-};
-export const isTheCurrentIntervalBigQuery = (node) => {
-    const isInsideOfDateTrunc = ['='].includes(node.operator) &&
-        node.left.type === 'function' &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args?.value[0]?.name?.toLowerCase() === 'current_timestamp';
-    return isInsideOfDateTrunc;
-};
-export const isEqualsBigQuery = (node) => {
-    const isEquals = ['='].includes(node.operator) &&
-        node.left.type === 'function' &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args.value[0].type.toLowerCase() === 'timestamp';
-    return isEquals;
-};

package/dist/esm/utils/parserPostgres.d.ts

@@ -1,3 +0,0 @@
-export declare const isInTheLastIntervalPostgres: (node: any) => boolean;
-export declare const isTheCurrentIntervalPostgres: (node: any) => boolean;
-//# sourceMappingURL=parserPostgres.d.ts.map

package/dist/esm/utils/parserPostgres.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parserPostgres.d.ts","sourceRoot":"","sources":["../../../src/utils/parserPostgres.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,SAAU,GAAG,KAAG,OAyBvD,CAAC;AAEF,eAAO,MAAM,4BAA4B,SAAU,GAAG,KAAG,OAiBxD,CAAC"}

package/dist/esm/utils/parserPostgres.js

@@ -1,37 +0,0 @@
-export const isInTheLastIntervalPostgres = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        node.left.type === 'column_ref' &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator === '-' &&
-        node.right.left.type === 'function' &&
-        node.right.left.name.toLowerCase() === 'date_trunc' &&
-        node.right.left.args.value[0].type === 'single_quote_string' &&
-        node.right.left.args.value[1].type === 'function' &&
-        ['current_date', 'now'].includes(node.right.left.args.value[1].name.toLowerCase()) &&
-        node.right.right.type.toLowerCase() === 'interval' &&
-        node.right.right.expr.type === 'single_quote_string';
-    const noDateTrunc = ['>=', '>'].includes(node.operator) &&
-        node.left.type === 'column_ref' &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator === '-' &&
-        node.right.left.type === 'function' &&
-        ['current_date', 'now'].includes(node.right.left.name.toLowerCase()) &&
-        node.right.right.type.toLowerCase() === 'interval' &&
-        node.right.right.expr.type === 'single_quote_string';
-    return isOutsideOfDateTrunc || noDateTrunc;
-};
-export const isTheCurrentIntervalPostgres = (node) => {
-    const isInsideOfDateTrunc = ['AND'].includes(node.operator) &&
-        (node.left.operator === '=' || node.left.type === 'double_quote_string') &&
-        node.right.operator === '=' &&
-        node.right.name &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.args.value[0].type === 'single_quote_string' &&
-        node.args.value[1].type === 'binary_expr' &&
-        node.args.value[1].operator === '-' &&
-        node.args.value[1].left.type === 'function' &&
-        ['now', 'current_date'].includes(node.args.value[1].left.name.toLowerCase()) &&
-        node.args.value[1].right.type === 'interval' &&
-        node.args.value[1].right.expr.type === 'single_quote_string';
-    return isInsideOfDateTrunc;
-};

package/dist/esm/utils/pivotConstructor.d.ts

@@ -1,7 +0,0 @@
-import { Pivot } from '../internals/ReportBuilder/PivotModal';
-import { QuillReportInternal } from '../models/Report';
-export declare function generatePivotWithSQL(pivot: Pivot, report: QuillReportInternal, client: any, dateBucket?: string, dateFilter?: any, distinctStrings?: any): Promise<{
-    rows: any;
-    columns: any;
-} | undefined>;
-//# sourceMappingURL=pivotConstructor.d.ts.map

package/dist/esm/utils/pivotConstructor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAOvD,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,GAAG,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,GAAG,EAChB,eAAe,CAAC,EAAE,GAAG;;;eAyLtB"}

package/dist/esm/utils/pivotConstructor.js

@@ -1,151 +0,0 @@
-import { dateFormatOptions } from '../ChartBuilder';
-import { isNumericColumnType } from '../components/ReportBuilder/ast';
-import { getDateString } from '../internals/ReportBuilder/PivotModal';
-import { processColumnName } from './columnProcessing';
-import { getData } from './dataFetcher';
-import { getComparisonInterval } from './dates';
-import { generatePivotQuery } from './queryConstructor';
-import { snakeCaseToTitleCase } from './textProcessing';
-export async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, distinctStrings) {
-    if (dateFilter && dateFilter.startDate) {
-        dateFilter.start = dateFilter.startDate;
-        dateFilter.end = dateFilter.endDate;
-        if (dateFilter.comparisonRange && dateFilter.comparisonRange.startDate) {
-            dateFilter.comparisonRange.start = dateFilter.comparisonRange.startDate;
-            dateFilter.comparisonRange.end = dateFilter.comparisonRange.endDate;
-        }
-    }
-    let comparisonInterval = undefined;
-    if (dateFilter && dateFilter.comparisonRange) {
-        comparisonInterval = getComparisonInterval({
-            startDate: dateFilter.comparisonRange.start,
-            endDate: dateFilter.comparisonRange.end,
-        }, dateBucket);
-    }
-    if (pivot.rowField && !pivot.rowFieldType) {
-        const rowColumn = report.columns.find((column) => column.field === pivot.rowField);
-        pivot.rowFieldType = rowColumn?.format || 'string';
-    }
-    let distinctStringValues = undefined;
-    if (!distinctStrings && report.rows && pivot.columnField) {
-        const distinctValues = Array.from(new Set(report.rows.map((row) => row[pivot.columnField])));
-        distinctStringValues = distinctValues.map((value) => value.toString());
-    }
-    if (!report.itemQuery) {
-        return undefined;
-    }
-    const sqlQuery = generatePivotQuery(pivot, report.itemQuery, client.databaseType, comparisonInterval, distinctStrings ? distinctStrings : distinctStringValues, dateBucket);
-    if (sqlQuery && report.rows.length > 0) {
-        const hostedBody = {
-            metadata: {
-                preQueries: [sqlQuery],
-                task: 'query',
-                orgId: client.customerId || '*',
-                clientId: client.publicKey,
-                databaseType: client?.databaseType,
-                getCustomFields: false,
-                runQueryConfig: {
-                    overridePost: true,
-                    convertDatatypes: true,
-                },
-                useNewNodeSql: true,
-            },
-        };
-        const cloudBody = { ...hostedBody };
-        const resp = await getData(client, 'query', 'same-origin', hostedBody, cloudBody, 'POST', 'fetch-pivot');
-        // With our current design we have to remove the second row field but leave the first for comparison purposes.
-        const rows = resp.queryResults[0].rows;
-        if (pivot.columnField && client.databaseType.toLowerCase() === 'bigquery') {
-            rows.forEach((row) => {
-                Object.keys(row).forEach((key) => {
-                    const processedKey = processColumnName(key);
-                    if (processedKey !== key) {
-                        row[processedKey] = row[key];
-                        delete row[key];
-                    }
-                });
-            });
-        }
-        const columns = resp.queryResults[0].fields
-            .map((field) => ({
-            field: processColumnName(field.name),
-            label: snakeCaseToTitleCase(processColumnName(field.name.replace('comparison_', 'comparison '))),
-            format: field.name === pivot.rowField
-                ? 'string'
-                : pivot.valueFieldType ?? 'whole_number',
-        }))
-            .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0)
-            .sort((a, b) => {
-            if (a.field === pivot.rowField) {
-                return -1;
-            }
-            if (b.field === pivot.rowField) {
-                return 1;
-            }
-            return 0;
-        });
-        if (pivot.rowField && !['string', 'varchar'].includes(pivot.rowFieldType)) {
-            rows.forEach((row) => {
-                row[pivot.rowField] = getDateString(row[pivot.rowField], undefined, dateBucket);
-            });
-            // add a row for each date in the range that doesn't have a value
-            if (pivot.rowField &&
-                !['string', 'varchar'].includes(pivot.rowFieldType) &&
-                dateFilter) {
-                const dateSet = new Set(rows.map((row) => row[pivot.rowField]));
-                // create a loop that will go through each formatted date and add a row if it doesn't exist going to the current date
-                for (let date = dateFilter.start ?? dateFilter.startDate; date <= dateFilter.end; date = new Date(date.getTime() + 24 * 60 * 60 * 1000)) {
-                    const formattedDate = getDateString(date.toDateString(), undefined, dateBucket);
-                    if (!dateSet.has(formattedDate)) {
-                        const newRow = {};
-                        newRow[pivot.rowField] = formattedDate;
-                        rows.push(newRow);
-                        dateSet.add(formattedDate);
-                    }
-                    // order the rows by the date field
-                    rows.sort((a, b) => {
-                        return new Date(a[pivot.rowField]) < new Date(b[pivot.rowField])
-                            ? -1
-                            : 1;
-                    });
-                }
-            }
-        }
-        if (pivot.sort) {
-            rows.sort((a, b) => {
-                if (pivot.sortDirection === 'ASC') {
-                    if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
-                        // @ts-ignore
-                        return new Date(a[pivot.sortField]) - new Date(b[pivot.sortField]);
-                    }
-                    else if (isNumericColumnType(pivot.sortFieldType)) {
-                        return a[pivot.sortField] - b[pivot.sortField];
-                    }
-                    return a[pivot.sortField].localeCompare(b[pivot.sortField]);
-                }
-                else {
-                    if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
-                        // @ts-ignore
-                        return new Date(b[pivot.sortField]) - new Date(a[pivot.sortField]);
-                    }
-                    else if (isNumericColumnType(pivot.sortFieldType)) {
-                        return b[pivot.sortField] - a[pivot.sortField];
-                    }
-                    return b[pivot.sortField].localeCompare(a[pivot.sortField]);
-                }
-            });
-        }
-        // for the case of count agg on no value field
-        columns.forEach((column) => {
-            if (['null', 'undefined'].includes(column.label.toLowerCase()) &&
-                !pivot.valueField &&
-                pivot.aggregationType === 'count') {
-                column.label = 'Count';
-            }
-        });
-        return {
-            rows: rows,
-            columns: columns,
-        };
-    }
-}

package/dist/esm/utils/pivotProcessing.d.ts

@@ -1,17 +0,0 @@
-import { Pivot } from '../internals/ReportBuilder/PivotModal';
-import { ColumnInternal } from '../models/Columns';
-export declare function pivotToSql(pivot: Pivot, query: string, columns: ColumnInternal[]): string;
-export declare function isValidPivot(pivot: Pivot): boolean;
-export declare function getPossiblePivotFieldOptions(columns: ColumnInternal[], uniqueValues: {
-    [field: string]: any;
-}): {
-    rowFields: string[];
-    columnFields: string[];
-    valueFields: string[];
-};
-export declare function cleanPivot(pivot: Pivot, possibleColumns: {
-    rowFields: any;
-    columnFields: any;
-    valueFields: any;
-}): Pivot;
-//# sourceMappingURL=pivotProcessing.d.ts.map

package/dist/esm/utils/pivotProcessing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAsCR;AAkBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,WA0BxC;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;;;;EAsCvC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAqCP"}