@quillsql/react 2.12.31 → 2.12.32

package/dist/esm/utils/columnProcessing.uspec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=columnProcessing.uspec.d.ts.map

package/dist/esm/utils/columnProcessing.uspec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"columnProcessing.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/columnProcessing.uspec.ts"],"names":[],"mappings":""}

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

@@ -1,65 +0,0 @@
-import { DEFAULT_COMPARISON_DATE_FILTER, TWO_D_PIVOT, GENERIC_REPORT_INTERNAL, ONE_D_PIVOT, } from '../test-utils/constants';
-import { createRows } from '../test-utils/generators';
-import { getYAxisFields } from './columnProcessing';
-describe('columnProcessing', () => {
-    describe('getYAxisFields', () => {
-        it('should return an array of fields for generic reports', () => {
-            const internalReport = {
-                ...GENERIC_REPORT_INTERNAL,
-                rows: createRows(GENERIC_REPORT_INTERNAL.columns, 10),
-            };
-            const result = getYAxisFields(internalReport);
-            expect(result).toEqual([
-                { field: 'id', format: 'whole_number', label: 'ID' },
-            ]);
-        });
-        it('should return an array of fields for comparison reports', () => {
-            const internalReport = {
-                ...GENERIC_REPORT_INTERNAL,
-                rows: createRows(GENERIC_REPORT_INTERNAL.columns, 10),
-                compareRows: createRows(GENERIC_REPORT_INTERNAL.columns, 10),
-                filtersApplied: [DEFAULT_COMPARISON_DATE_FILTER],
-            };
-            const result = getYAxisFields(internalReport);
-            expect(result).toEqual([
-                { field: 'id', format: 'whole_number', label: 'ID' },
-                {
-                    field: 'comparison_id',
-                    format: 'whole_number',
-                    label: 'comparison ID',
-                },
-            ]);
-        });
-        it('should return the proper fields for a 2d pivot report', () => {
-            const internalReport = {
-                ...GENERIC_REPORT_INTERNAL,
-                rows: createRows(GENERIC_REPORT_INTERNAL.columns, 10),
-                pivotColumns: TWO_D_PIVOT.pivotColumns,
-                pivotRows: TWO_D_PIVOT.pivotRows,
-                pivot: TWO_D_PIVOT.pivot,
-            };
-            const result = getYAxisFields(internalReport);
-            expect(result).toEqual([
-                { field: 'Food', format: 'whole_number', label: 'Food' },
-                { field: 'Fuel', format: 'whole_number', label: 'Fuel' },
-                { field: 'Other', format: 'whole_number', label: 'Other' },
-            ]);
-        });
-        it('should return the proper fields for a 1d pivot report', () => {
-            const internalReport = {
-                ...GENERIC_REPORT_INTERNAL,
-                rows: createRows(GENERIC_REPORT_INTERNAL.columns, 10),
-                pivotColumns: ONE_D_PIVOT.pivotColumns,
-                pivotRows: ONE_D_PIVOT.pivotRows,
-                pivot: ONE_D_PIVOT.pivot,
-                yAxisFields: [
-                    { field: 'amount', format: 'whole_number', label: 'Amount' },
-                ],
-            };
-            const result = getYAxisFields(internalReport);
-            expect(result).toEqual([
-                { field: 'amount', format: 'whole_number', label: 'Amount' },
-            ]);
-        });
-    });
-});

package/dist/esm/utils/dataProcessing.uspec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dataProcessing.uspec.d.ts.map

package/dist/esm/utils/dataProcessing.uspec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataProcessing.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/dataProcessing.uspec.ts"],"names":[],"mappings":""}

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

@@ -1,205 +0,0 @@
-import { getPointToPointPercentageChange, getSimplePercentageChange, } from './dataProcessing';
-const defaultReport = {
-    id: 'dummy',
-    name: 'dummy',
-    dashboardName: 'dummy',
-    chartType: 'dummy',
-    dateField: null,
-    columns: [],
-    filtersApplied: [],
-    order: 0,
-    queryString: 'dummy',
-    compareRows: [{ amount: '20' }, { amount: '20' }],
-    rowCount: 0,
-    pivot: null,
-    rows: [
-        { amount: '40', created_at: '2024-06-01' },
-        { amount: '20', created_at: '2024-07-02' },
-    ],
-    xAxisField: 'date',
-    xAxisFormat: 'string',
-    xAxisLabel: 'Date',
-    yAxisFields: [{ field: 'amount', label: 'Amount', format: 'string' }],
-};
-describe('getSimplePercentageChange', () => {
-    it('should get the simple percentage without a pivot', () => {
-        const result = getSimplePercentageChange(defaultReport);
-        expect(result).toEqual(0.5);
-    });
-    it('should get the simple percentage with 1D pivot', () => {
-        const report = {
-            ...defaultReport,
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'merchant',
-                rowFieldType: 'dummy',
-                columnField: 'dummy',
-                columnFieldType: 'dummy',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            pivotRows: [
-                { merchant: 'dummy-merchant', amount: 15, comparison_amount: 10 },
-            ],
-            pivotColumns: [
-                { field: 'comparison_amount', label: 'Amount', format: 'string' },
-                { field: 'amount', label: 'Amount', format: 'string' },
-                { field: 'merchant', label: 'Merchant', format: 'string' },
-            ],
-        };
-        // @ts-ignore
-        const result = getSimplePercentageChange(report);
-        expect(result).toEqual(0.5);
-    });
-    it('should get the simple percentage with 1D pivot', () => {
-        const report = {
-            ...defaultReport,
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'merchant',
-                rowFieldType: 'string',
-                columnField: 'user_name',
-                columnFieldType: 'string',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            pivotRows: [{ dummy: 'subway', subway: 15, comparison_subway: 10 }],
-            pivotColumns: [
-                { label: 'dummy', field: 'user_name' },
-                { label: 'subway', field: 'subway' },
-                { label: 'comparison_subway', field: 'comparison_subway' },
-            ],
-        };
-        // @ts-ignore
-        const result = getSimplePercentageChange(report);
-        expect(result).toEqual(0.5);
-    });
-    it('should fallback to point to point', () => {
-        const report = {
-            ...defaultReport,
-            compareRows: null,
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'merchant',
-                rowFieldType: 'string',
-                columnField: 'user_name',
-                columnFieldType: 'string',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            dateField: { table: 'table', field: 'created_at' },
-            pivotRows: [{ dummy: 'subway', subway: 15, comparison_subway: 10 }],
-            pivotColumns: [
-                { label: 'dummy', field: 'user_name' },
-                { label: 'subway', field: 'subway' },
-                { label: 'comparison_subway', field: 'comparison_subway' },
-            ],
-        };
-        //@ts-ignore
-        const result = getSimplePercentageChange(report);
-        expect(result).toEqual(-1);
-    });
-});
-describe('getPointToPointPercentageChange', () => {
-    it('should get the point to point percentage change', () => {
-        const report = {
-            ...defaultReport,
-            compareRows: [],
-            dateField: { table: 'table', field: 'created_at' },
-        };
-        const result = getPointToPointPercentageChange(report);
-        expect(result).toEqual(-1);
-    });
-    it('should work with 1d date pivots', () => {
-        const report = {
-            ...defaultReport,
-            compareRows: [],
-            dateField: { table: 'table', field: 'created_at' },
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'created_at',
-                rowFieldType: 'date',
-                columnField: 'user_name',
-                columnFieldType: 'string',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            pivotRows: [
-                { created_at: '2024-01-01', amount: '20' },
-                { created_at: '2024-02-01', amount: '30' },
-            ],
-            pivotColumns: [
-                { label: 'created_at', field: 'created_at' },
-                { label: 'amount', field: 'amount' },
-            ],
-        };
-        // @ts-ignore
-        const result = getPointToPointPercentageChange(report);
-        expect(result).toEqual(0.5);
-    });
-    it('should only use the first and last buckets', () => {
-        const report = {
-            ...defaultReport,
-            compareRows: [],
-            dateField: { table: 'table', field: 'created_at' },
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'created_at',
-                rowFieldType: 'date',
-                columnField: 'user_name',
-                columnFieldType: 'string',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            pivotRows: [
-                { created_at: '2024-01-01', amount: '20' },
-                { created_at: '2024-02-01', amount: '20' },
-                { created_at: '2024-03-01', amount: '30' },
-                { created_at: '2024-05-01', amount: '40' },
-            ],
-            pivotColumns: [
-                { label: 'created_at', field: 'created_at' },
-                { label: 'amount', field: 'amount' },
-            ],
-        };
-        // @ts-ignore
-        const result = getPointToPointPercentageChange(report);
-        expect(result).toEqual(1);
-    });
-    it('should work with 2d pivots', () => {
-        const report = {
-            ...defaultReport,
-            compareRows: [],
-            dateField: { table: 'table', field: 'created_at' },
-            pivot: {
-                title: 'dummy',
-                aggregationType: 'sum',
-                rowField: 'created_at',
-                rowFieldType: 'date',
-                columnField: 'user_name',
-                columnFieldType: 'string',
-                valueField: 'amount',
-                valueFieldType: 'number',
-            },
-            pivotRows: [
-                { created_at: '2024-01-01', subway: '20', mcdonalds: '30' },
-                { created_at: '2024-02-01', subway: '20', mcdonalds: '30' },
-                { created_at: '2024-03-01', subway: '30', mcdonalds: '30' },
-                { created_at: '2024-04-01', subway: '50', mcdonalds: '100' },
-            ],
-            pivotColumns: [
-                { label: 'created_at', field: 'created_at' },
-                { label: 'subway', field: 'subway' },
-                { label: 'mcdonalds', field: 'mcdonalds' },
-            ],
-        };
-        // @ts-ignore
-        const result = getPointToPointPercentageChange(report);
-        expect(result).toEqual(2);
-    });
-});

package/dist/esm/utils/filterProcessing.uspec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=filterProcessing.uspec.d.ts.map

package/dist/esm/utils/filterProcessing.uspec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterProcessing.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/filterProcessing.uspec.ts"],"names":[],"mappings":""}

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

@@ -1,245 +0,0 @@
-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/queryConstructor.uspec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=queryConstructor.uspec.d.ts.map

package/dist/esm/utils/queryConstructor.uspec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryConstructor.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.uspec.ts"],"names":[],"mappings":""}