@quillsql/react 2.15.3 → 2.15.4

package/dist/esm/utils/merge.js

@@ -1,227 +0,0 @@
-import { add, startOfDay, startOfMonth, startOfWeek, startOfYear, } from 'date-fns';
-import { isStringType } from './columnType';
-import { utcToZonedTime } from 'date-fns-tz';
-// FIXME: Update all of this as part of restoring date comparisons
-export function mergeComparisonRange(resp) {
-    if (resp.chartType === 'table')
-        return resp;
-    const compRows = resp.compareRows;
-    if (!compRows)
-        return resp;
-    const newRows = resp.rows.map((row, i) => {
-        if (i < compRows.length) {
-            const compRow = compRows[i];
-            const newRow = { ...row };
-            for (const [key, value] of Object.entries(compRow)) {
-                newRow[`comparison_${key}`] = value;
-            }
-            return newRow;
-        }
-        return row;
-    });
-    return { ...resp, rows: newRows };
-}
-export function dateAdder(date, interval) {
-    const match = interval.match(/^(\d+)\s+(day|month|year)$/);
-    if (!match) {
-        throw new Error(`Invalid interval format: ${interval}`);
-    }
-    const [, valueStr, unit] = match;
-    if (!valueStr || !unit) {
-        throw new Error('Could not parse interval');
-    }
-    const value = parseInt(valueStr, 10);
-    const parsedDate = typeof date === 'string' ? new Date(date) : date;
-    switch (unit) {
-        case 'day':
-            return add(parsedDate, { days: value });
-        case 'month':
-            return add(parsedDate, { months: value });
-        case 'year':
-            return add(parsedDate, { years: value });
-        default:
-            throw new Error(`Unsupported interval unit: ${unit}`);
-    }
-}
-function dateTrunc(date, granularity = 'day', databaseType) {
-    const weekStartsOn = databaseType === 'mssql' ? 0 : 1;
-    const timeZone = 'UTC'; // standardize
-    const zonedDate = utcToZonedTime(date, timeZone);
-    switch (granularity.toLowerCase()) {
-        case 'week':
-            return startOfWeek(zonedDate, { weekStartsOn });
-        case 'month':
-            return startOfMonth(zonedDate);
-        case 'day':
-            return startOfDay(zonedDate);
-        case 'year':
-            return startOfYear(zonedDate);
-        default:
-            throw new Error(`Unsupported granularity: ${granularity}`);
-    }
-}
-export function mergeComparisonPivotColumns({ pivot, rows, compRows, }) {
-    if (!compRows || !compRows.length)
-        return rows;
-    const mappedCompRows = compRows
-        .filter((compRow) => compRow.name !== pivot.rowField)
-        .map((compRow) => ({ ...compRow, name: `comparison_${compRow.name}` }));
-    return rows.concat(mappedCompRows);
-}
-export function mergeComparisonPivotRows({ pivot, rows, compRows, databaseType, dateBucket, comparisonInterval, columnFieldValues, }) {
-    if (!compRows || !compRows.length)
-        return rows;
-    if (pivot.columnField && columnFieldValues && columnFieldValues.length > 0) {
-        return merge2DPivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval);
-    }
-    if (pivot.rowField) {
-        return merge1DPivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval);
-    }
-    return mergeAggregatedRows(pivot, rows, compRows);
-}
-function merge2DPivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
-    if (!pivot || !pivot.columnField) {
-        return [];
-    }
-    if (isStringType(pivot.rowFieldType || '') || !pivot.rowFieldType) {
-        return merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues);
-    }
-    return merge2DDatePivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval);
-}
-function merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues) {
-    if (!pivot.rowField || !pivot.aggregations?.some((agg) => agg.valueField)) {
-        return rows;
-    }
-    return rows.map((row) => {
-        const matchingCompRow = compRows.find((compRow) => compRow[pivot.rowField] === row[pivot.rowField]);
-        const comparisonFields = columnFieldValues.reduce((acc, fieldValue) => {
-            acc[`comparison_${fieldValue}`] = matchingCompRow
-                ? matchingCompRow[fieldValue] || null
-                : null;
-            return acc;
-        }, {});
-        return {
-            ...row,
-            ...comparisonFields,
-        };
-    });
-}
-function merge2DDatePivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
-    if (!comparisonInterval || !pivot.rowField) {
-        return rows;
-    }
-    return rows.map((row) => {
-        // Truncate the row date to match the SQL behavior
-        const rowDate = typeof row[pivot.rowField] === 'string'
-            ? new Date(row[pivot.rowField])
-            : row[pivot.rowField];
-        const truncatedRowDate = dateTrunc(rowDate, dateBucket, databaseType);
-        // Find a matching compRow where adding the interval matches the truncatedRowDate
-        const matchingCompRow = compRows.find((compRow) => {
-            const comparisonDateWithInterval = dateAdder(compRow[pivot.rowField], comparisonInterval);
-            const truncatedCompRowDate = dateTrunc(comparisonDateWithInterval, dateBucket, databaseType);
-            return (truncatedRowDate.toISOString() === truncatedCompRowDate.toISOString());
-        });
-        // Create comparison fields for each column value
-        const comparisonFields = columnFieldValues.reduce((acc, fieldValue) => {
-            acc[`comparison_${fieldValue}`] = matchingCompRow
-                ? matchingCompRow[fieldValue] || null
-                : null;
-            return acc;
-        }, {});
-        return {
-            ...row,
-            ...comparisonFields,
-        };
-    });
-}
-function merge1DPivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
-    if (isStringType(pivot.rowFieldType || '') || !pivot.rowFieldType) {
-        return merge1DStringPivotRows(pivot, rows, compRows);
-    }
-    return merge1DDatePivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval);
-}
-function merge1DStringPivotRows(pivot, rows, compRows) {
-    if (!pivot.rowField || !pivot.valueField) {
-        return rows;
-    }
-    return rows.map((row) => {
-        const matchingCompRow = compRows.find((compRow) => compRow[pivot.rowField] === row[pivot.rowField]);
-        let aggregationSuffix = '';
-        // match 'percentage' casing
-        if (matchingCompRow && pivot.aggregationType === 'percentage') {
-            if (matchingCompRow[`${pivot.valueField}_Percentage`]) {
-                aggregationSuffix = '_Percentage';
-            }
-            else if (matchingCompRow[`${pivot.valueField}_PERCENTAGE`]) {
-                aggregationSuffix = '_PERCENTAGE';
-            }
-            else {
-                aggregationSuffix = '_percentage';
-            }
-        }
-        // Return the merged row with the value from compRows, or null if no match is found
-        return {
-            ...row,
-            [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow
-                ? matchingCompRow[`${pivot.valueField}${aggregationSuffix}`]
-                : null,
-        };
-    });
-}
-function merge1DDatePivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
-    if (!comparisonInterval || !pivot.rowField) {
-        return rows;
-    }
-    return rows.map((row) => {
-        // Truncate the row date to match the SQL behavior
-        const rowDate = typeof row[pivot.rowField] === 'string'
-            ? new Date(row[pivot.rowField])
-            : row[pivot.rowField];
-        const truncatedRowDate = dateTrunc(rowDate, dateBucket, databaseType);
-        // Find a matching compRow where adding the interval matches the truncatedRowDate
-        const matchingCompRow = compRows.find((compRow) => {
-            const comparisonDateWithInterval = dateAdder(compRow[`${pivot.rowField}`], comparisonInterval);
-            const truncatedCompRowDate = dateTrunc(comparisonDateWithInterval, dateBucket, databaseType);
-            return (truncatedRowDate.toISOString() === truncatedCompRowDate.toISOString());
-        });
-        let aggregationSuffix = '';
-        // match 'percentage' casing
-        if (matchingCompRow && pivot.aggregationType === 'percentage') {
-            if (matchingCompRow[`${pivot.valueField}_Percentage`]) {
-                aggregationSuffix = '_Percentage';
-            }
-            else if (matchingCompRow[`${pivot.valueField}_PERCENTAGE`]) {
-                aggregationSuffix = '_PERCENTAGE';
-            }
-            else {
-                aggregationSuffix = '_percentage';
-            }
-        }
-        return {
-            ...row,
-            [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow?.[`${pivot.valueField}${aggregationSuffix}`] || null,
-        };
-    });
-}
-function mergeAggregatedRows(pivot, rows, compRows) {
-    return rows.map((row, i) => {
-        let aggregationSuffix = '';
-        // match 'percentage' casing
-        if (compRows[i] && pivot.aggregationType === 'percentage') {
-            if (compRows[i][`${pivot.valueField}_Percentage`]) {
-                aggregationSuffix = '_Percentage';
-            }
-            else if (compRows[i][`${pivot.valueField}_PERCENTAGE`]) {
-                aggregationSuffix = '_PERCENTAGE';
-            }
-            else {
-                aggregationSuffix = '_percentage';
-            }
-        }
-        const compRow = {
-            [`comparison_${pivot.valueField}${aggregationSuffix}`]: compRows[i]?.[`${pivot.valueField}${aggregationSuffix}`],
-        };
-        return { ...row, ...compRow };
-    });
-}

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

@@ -1,22 +0,0 @@
-import { Monaco } from '@monaco-editor/react';
-import { Range } from 'monaco-editor';
-import { Table } from '../models/Tables';
-interface CompletionItem {
-    label: string;
-    kind: number;
-    insertText: string;
-    insertTextRules: number;
-    range: Range;
-    detail?: string;
-}
-export declare const QUILL_LANGUAGE: any;
-export declare function generateSuggestionsBySchema(schema: Table[], monaco: Monaco, range: Range, databaseType: string): CompletionItem[];
-export declare function generateSuggestionsByDatasource(monaco: Monaco, range: Range, databaseType: string): {
-    label: string;
-    kind: import("monaco-editor").languages.CompletionItemKind;
-    insertText: string;
-    insertTextRules: import("monaco-editor").languages.CompletionItemInsertTextRule;
-    range: Range;
-}[];
-export {};
-//# sourceMappingURL=monacoConfig.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAEtC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,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,KAAK,EAAE,EACf,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

@@ -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.field, databaseType).replaceAll('`', '')}`;
-            const curSuggestion = {
-                label: column.field,
-                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,6 +0,0 @@
-import { Pagination } from '../models/Pagination';
-export declare const DEFAULT_PAGINATION: Pagination;
-export declare const DEFAULT_TABLE_PAGINATION: Pagination;
-export declare function shouldFetchMore(pagination: Pagination, page: number, maxPage: number, currentRowCount?: number): boolean;
-export declare function shouldSortInMemory(pagination: Pagination, rowCount?: number): 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,eAAO,MAAM,wBAAwB,EAAE,UAItC,CAAC;AAEF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,WAkBzB;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,WAK3E"}

package/dist/esm/utils/paginationProcessing.js

@@ -1,28 +0,0 @@
-export const DEFAULT_PAGINATION = {
-    page: 0,
-    rowsPerPage: 10,
-    rowsPerRequest: 600,
-};
-export const DEFAULT_TABLE_PAGINATION = {
-    page: 0,
-    rowsPerPage: 10,
-    rowsPerRequest: 50,
-};
-export function shouldFetchMore(pagination, page, maxPage, currentRowCount) {
-    if (!pagination ||
-        (currentRowCount && currentRowCount >= pagination.rowsPerPage * (page + 1))) {
-        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) {
-    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,GAAI,MAAM,GAAG,YAYpD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,GAAG,YAUxC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,GAAG,YAUzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,MAAM,GAAG,KAAG,OAUxD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,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