@quillsql/react 2.12.29 → 2.12.31

package/dist/esm/utils/filterProcessing.uspec.js

@@ -0,0 +1,245 @@
+import { BoolOperator, DateOperator, FieldTypes, FilterNames, NullOperator, NumberOperator, StringOperator, } from '../models/Filter';
+import { filterSentence } from './filterProcessing';
+describe('filterSentence', () => {
+    it('should handle null filters', () => {
+        const isNullFilter = {
+            name: FilterNames.NullFilter,
+            operator: NullOperator.IsNull,
+            field: 'field',
+            type: FieldTypes.Null,
+            value: null,
+        };
+        const isNotNullFilter = {
+            name: FilterNames.NullFilter,
+            operator: NullOperator.IsNotNull,
+            field: 'field',
+            type: FieldTypes.Null,
+            value: null,
+        };
+        expect(filterSentence(isNullFilter)).toEqual('Field is null');
+        expect(filterSentence(isNotNullFilter)).toEqual('Field is not null');
+    });
+    it('should handle string filters', () => {
+        const stringExactlyFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsExactly,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        const stringNotExactlyFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsNotExactly,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        const stringContainsFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.Contains,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        expect(filterSentence(stringExactlyFilter)).toEqual('Field is exactly this');
+        expect(filterSentence(stringNotExactlyFilter)).toEqual('Field is not exactly this');
+        expect(filterSentence(stringContainsFilter)).toEqual('Field contains this');
+    });
+    it('should handle number filters', () => {
+        const numberEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberNotEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberGreaterThanFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.GreaterThan,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberLessThanFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.LessThan,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberGreaterThanOrEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.GreaterThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberLessThanOrEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.LessThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        expect(filterSentence(numberEqualToFilter)).toEqual('Field equal to 0');
+        expect(filterSentence(numberNotEqualToFilter)).toEqual('Field not equal to 0');
+        expect(filterSentence(numberGreaterThanFilter)).toEqual('Field greater than 0');
+        expect(filterSentence(numberLessThanFilter)).toEqual('Field less than 0');
+        expect(filterSentence(numberGreaterThanOrEqualToFilter)).toEqual('Field greater than or equal to 0');
+        expect(filterSentence(numberLessThanOrEqualToFilter)).toEqual('Field less than or equal to 0');
+    });
+    it('should handle boolean filters', () => {
+        const booleanEqualToFilter = {
+            name: FilterNames.BooleanFilter,
+            operator: BoolOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Boolean,
+            value: true,
+        };
+        const booleanNotEqualToFilter = {
+            name: FilterNames.BooleanFilter,
+            operator: BoolOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Boolean,
+            value: true,
+        };
+        expect(filterSentence(booleanEqualToFilter)).toEqual('Field equal to true');
+        expect(filterSentence(booleanNotEqualToFilter)).toEqual('Field not equal to true');
+    });
+    it('should handle date filters', () => {
+        const dateInTheLastFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheLast,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 10, unit: 'day' },
+        };
+        const dateInTheLastFilterSingular = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheLast,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        const dateInTheCurrentFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheCurrent,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        const dateInThePreviousFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InThePrevious,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 10, unit: 'day' },
+        };
+        const dateInThePreviousFilterSingular = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InThePrevious,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        expect(filterSentence(dateInTheLastFilter)).toEqual('Field in the last 10 days');
+        expect(filterSentence(dateInTheLastFilterSingular)).toEqual('Field in the last 1 day');
+        expect(filterSentence(dateInTheCurrentFilter)).toEqual('Field in the current day');
+        expect(filterSentence(dateInThePreviousFilter)).toEqual('Field in the previous 10 days');
+        expect(filterSentence(dateInThePreviousFilterSingular)).toEqual('Field in the previous 1 day');
+    });
+    it('should handle date comparison filters', () => {
+        const dateEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateNotEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateGreaterThanFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.GreaterThan,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateLessThanFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.LessThan,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateGreaterThanOrEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.GreaterThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateLessThanOrEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.LessThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        expect(filterSentence(dateEqualToFilter)).toEqual('Field equal to 2021-01-01');
+        expect(filterSentence(dateNotEqualToFilter)).toEqual('Field not equal to 2021-01-01');
+        expect(filterSentence(dateGreaterThanFilter)).toEqual('Field greater than 2021-01-01');
+        expect(filterSentence(dateLessThanFilter)).toEqual('Field less than 2021-01-01');
+        expect(filterSentence(dateGreaterThanOrEqualToFilter)).toEqual('Field greater than or equal to 2021-01-01');
+        expect(filterSentence(dateLessThanOrEqualToFilter)).toEqual('Field less than or equal to 2021-01-01');
+    });
+    it('should handle custom date filters', () => {
+        const dateCustomFilter = {
+            name: FilterNames.DateCustomFilter,
+            operator: DateOperator.Custom,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { startDate: '2021-01-01', endDate: '2021-12-31' },
+        };
+        expect(filterSentence(dateCustomFilter)).toEqual('Field custom from 2021-01-01');
+    });
+    it('should handle string in filters', () => {
+        const stringIsFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.Is,
+            field: 'field',
+            type: FieldTypes.String,
+            value: ['this', 'that'],
+        };
+        const stringIsNotFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsNot,
+            field: 'field',
+            type: FieldTypes.String,
+            value: ['this', 'that'],
+        };
+        expect(filterSentence(stringIsFilter)).toEqual('Field is one of this, that');
+        expect(filterSentence(stringIsNotFilter)).toEqual('Field is not one of this, that');
+    });
+    it('should throw an error for invalid filters', () => {
+        const invalidFilter = {
+            name: 'filter',
+            operator: '=',
+            field: 'field',
+            type: 'string',
+        };
+        expect(filterSentence(invalidFilter)).toEqual('Error: filter missing value');
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/utils/logging.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,QAKpE"}
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/utils/logging.ts"],"names":[],"mappings":"AACA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,QAKpE"}

package/dist/esm/utils/logging.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-undef */
 export function internalLog(message, ...optionalParams) {
     if (process.env.QUILL_ENV === 'development') {
         const completeMessage = `Quill: ${message}: ${optionalParams.join('\n')}`;

package/dist/esm/utils/merge.js

@@ -16,24 +16,3 @@ function mergeForwards(resp) {
         j++;
     }
 }
-// eslint-disable-next-line no-unused-vars
-function mergeBackwards(resp) {
-    const compRows = resp.compareRows;
-    let j = compRows.length - 1;
-    for (let i = resp.rows.length - 1; i >= 0; i--) {
-        if (j >= 0) {
-            for (const [key, value] of Object.entries(compRows[j])) {
-                resp.rows[i][`comparison_${key}`] = value;
-            }
-        }
-        j--;
-    }
-    while (j >= 0) {
-        const obj = {};
-        for (const [key, value] of Object.entries(compRows[j])) {
-            obj[`comparison_${key}`] = value;
-        }
-        resp.rows.push(obj);
-        j--;
-    }
-}

package/dist/esm/utils/{monacoAutocomplete.d.ts → monacoConfig.d.ts}

@@ -5,9 +5,10 @@ interface CompletionItem {
     kind: number;
     insertText: string;
     insertTextRules: number;
-    range: any;
+    range: Range;
     detail?: string;
 }
+export declare const QUILL_LANGUAGE: any;
 export declare function generateSuggestionsBySchema(schema: any[], monaco: Monaco, range: Range, databaseType: string): CompletionItem[];
 export declare function generateSuggestionsByDatasource(monaco: Monaco, range: Range, databaseType: string): {
     label: string;
@@ -17,4 +18,4 @@ export declare function generateSuggestionsByDatasource(monaco: Monaco, range: R
     range: Range;
 }[];
 export {};
-//# sourceMappingURL=monacoAutocomplete.d.ts.map
+//# sourceMappingURL=monacoConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monacoConfig.d.ts","sourceRoot":"","sources":["../../../src/utils/monacoConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAGtC,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,cAAc,EAAE,GAmJ5B,CAAC;AAyJF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,GAAG,EAAE,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,GACnB,cAAc,EAAE,CA2BlB;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM;;;;;;IAoBrB"}

package/dist/esm/utils/monacoConfig.js

@@ -0,0 +1,319 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+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/pivotConstructor.d.ts

@@ -1,5 +1,6 @@
 import { Pivot } from '../internals/ReportBuilder/PivotModal';
-export declare function generatePivotWithSQL(pivot: Pivot, report: any, client: any, dateBucket?: string, dateFilter?: any, distinctStrings?: any): Promise<{
+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>;

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

@@ -1 +1 @@
-{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAO7E,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,GAAG,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,GAAG,EAChB,eAAe,CAAC,EAAE,GAAG;;;eAsKtB"}
+{"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"}