@sisense/sdk-data 1.14.0 → 1.15.1

package/dist/cjs/dimensional-model/measures/factory.test.js

@@ -1,481 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable vitest/expect-expect */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable max-params */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable vitest/no-identical-title */
-const attributes_js_1 = require("../attributes.js");
-const measures_js_1 = require("./measures.js");
-const dimensions_js_1 = require("../dimensions.js");
-const types_js_1 = require("../types.js");
-const base_js_1 = require("../base.js");
-const filterFactory = __importStar(require("../filters/factory.js"));
-const measureFactory = __importStar(require("./factory.js"));
-const sampleAttribute = new attributes_js_1.DimensionalAttribute('Cost', '[Commerce.Cost]', 'numeric-attribute');
-const sampleMeasureName = 'measure name';
-const sampleMeasureFormat = '00.00';
-const sampleMeasure1 = new measures_js_1.DimensionalBaseMeasure('measure 1', sampleAttribute, types_js_1.AggregationTypes.Sum);
-const sampleMeasure2 = new measures_js_1.DimensionalBaseMeasure('measure 2', sampleAttribute, types_js_1.AggregationTypes.Average);
-const getContextName = (target) => {
-    return `[${(0, base_js_1.normalizeName)(target.name)}]`;
-};
-const verifyMeasure = (m, expectedAggregationType) => {
-    expect(m).toBeInstanceOf(measures_js_1.DimensionalBaseMeasure);
-    expect(m).toHaveProperty('aggregation', expectedAggregationType);
-    expect(m).toHaveProperty('attribute', sampleAttribute);
-    expect(m).toHaveProperty('name', sampleMeasureName);
-    expect(m.getFormat()).toBe(sampleMeasureFormat);
-};
-const verifyCalculatedMeasure = (m, expectedExpression, expectedContext, expectedName) => {
-    expect(m).toBeInstanceOf(measures_js_1.DimensionalCalculatedMeasure);
-    expect(m).toHaveProperty('expression', expectedExpression);
-    expect(m).toHaveProperty('context', expectedContext);
-    expect(m).toHaveProperty('name', expectedName !== null && expectedName !== void 0 ? expectedName : sampleMeasureName);
-};
-describe('measureFactory', () => {
-    describe('constant', () => {
-        test('measureFactory.constant()', () => {
-            const m = measureFactory.constant(42);
-            verifyCalculatedMeasure(m, '42', {}, '42');
-        });
-    });
-    describe('aggregations', () => {
-        test('measureFactory.sum()', () => {
-            const m = measureFactory.sum(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Sum);
-        });
-        test('measureFactory.average()', () => {
-            const m = measureFactory.average(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Average);
-        });
-        test('measureFactory.min()', () => {
-            const m = measureFactory.min(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Min);
-        });
-        test('measureFactory.max()', () => {
-            const m = measureFactory.max(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Max);
-        });
-        test('measureFactory.max()', () => {
-            const m = measureFactory.max(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Max);
-        });
-        test('measureFactory.median()', () => {
-            const m = measureFactory.median(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Median);
-        });
-        test('measureFactory.count()', () => {
-            const m = measureFactory.count(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.Count);
-        });
-        test('measureFactory.countDistinct()', () => {
-            const m = measureFactory.countDistinct(sampleAttribute, sampleMeasureName, sampleMeasureFormat);
-            verifyMeasure(m, types_js_1.AggregationTypes.CountDistinct);
-        });
-    });
-    describe('unary formula functions', () => {
-        const expectedContext = {
-            '[measure1]': sampleMeasure1,
-        };
-        test('measureFactory.yearToDateSum()', () => {
-            const m = measureFactory.yearToDateSum(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'YTDSum([measure1])', expectedContext);
-        });
-        test('measureFactory.quarterToDateSum()', () => {
-            const m = measureFactory.quarterToDateSum(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'QTDSum([measure1])', expectedContext);
-        });
-        test('measureFactory.monthToDateSum()', () => {
-            const m = measureFactory.monthToDateSum(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'MTDSum([measure1])', expectedContext);
-        });
-        test('measureFactory.weekToDateSum()', () => {
-            const m = measureFactory.weekToDateSum(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'WTDSum([measure1])', expectedContext);
-        });
-        test('measureFactory.runningSum()', () => {
-            const m = measureFactory.runningSum(sampleMeasure1, false, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'RSum([measure1])', expectedContext);
-        });
-        test('measureFactory.growth()', () => {
-            const m = measureFactory.growth(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growth([measure1])', expectedContext);
-        });
-        test('measureFactory.growthRate()', () => {
-            const m = measureFactory.growthRate(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growthrate([measure1])', expectedContext);
-        });
-        test('measureFactory.growthPastWeek()', () => {
-            const m = measureFactory.growthPastWeek(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growthpastweek([measure1])', expectedContext);
-        });
-        test('measureFactory.growthPastMonth()', () => {
-            const m = measureFactory.growthPastMonth(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growthpastmonth([measure1])', expectedContext);
-        });
-        test('measureFactory.growthPastQuarter()', () => {
-            const m = measureFactory.growthPastQuarter(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growthpastquarter([measure1])', expectedContext);
-        });
-        test('measureFactory.growthPastYear()', () => {
-            const m = measureFactory.growthPastYear(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'growthpastyear([measure1])', expectedContext);
-        });
-        test('measureFactory.difference()', () => {
-            const m = measureFactory.difference(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'diffpastperiod([measure1])', expectedContext);
-        });
-        test('measureFactory.diffPastWeek()', () => {
-            const m = measureFactory.diffPastWeek(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'diffpastweek([measure1])', expectedContext);
-        });
-        test('measureFactory.diffPastMonth()', () => {
-            const m = measureFactory.diffPastMonth(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'diffpastmonth([measure1])', expectedContext);
-        });
-        test('measureFactory.diffPastQuarter()', () => {
-            const m = measureFactory.diffPastQuarter(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'diffpastquarter([measure1])', expectedContext);
-        });
-        test('measureFactory.diffPastYear()', () => {
-            const m = measureFactory.diffPastYear(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'diffpastyear([measure1])', expectedContext);
-        });
-        test('measureFactory.pastDay()', () => {
-            const m = measureFactory.pastDay(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'pastday([measure1])', expectedContext);
-        });
-        test('measureFactory.pastWeek()', () => {
-            const m = measureFactory.pastWeek(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'pastweek([measure1])', expectedContext);
-        });
-        test('measureFactory.pastMonth()', () => {
-            const m = measureFactory.pastMonth(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'pastmonth([measure1])', expectedContext);
-        });
-        test('measureFactory.pastQuarter()', () => {
-            const m = measureFactory.pastQuarter(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'pastquarter([measure1])', expectedContext);
-        });
-        test('measureFactory.pastYear()', () => {
-            const m = measureFactory.pastYear(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'pastyear([measure1])', expectedContext);
-        });
-        test('measureFactory.contribution()', () => {
-            const m = measureFactory.contribution(sampleMeasure1, sampleMeasureName);
-            verifyCalculatedMeasure(m, 'contribution([measure1])', expectedContext);
-        });
-    });
-    describe('arithmetical formula functions', () => {
-        describe('operands: two measures', () => {
-            const expectedContext = {
-                '[measure1]': sampleMeasure1,
-                '[measure2]': sampleMeasure2,
-            };
-            test('measureFactory.add()', () => {
-                const m = measureFactory.add(sampleMeasure1, sampleMeasure2, sampleMeasureName, false);
-                verifyCalculatedMeasure(m, '[measure1]+[measure2]', expectedContext);
-            });
-            test('measureFactory.subtract()', () => {
-                const m = measureFactory.subtract(sampleMeasure1, sampleMeasure2, sampleMeasureName, false);
-                verifyCalculatedMeasure(m, '[measure1]-[measure2]', expectedContext);
-            });
-            test('measureFactory.multiply()', () => {
-                const m = measureFactory.multiply(sampleMeasure1, sampleMeasure2, sampleMeasureName, false);
-                verifyCalculatedMeasure(m, '[measure1]*[measure2]', expectedContext);
-            });
-            test('measureFactory.divide()', () => {
-                const m = measureFactory.divide(sampleMeasure1, sampleMeasure2, sampleMeasureName, false);
-                verifyCalculatedMeasure(m, '[measure1]/[measure2]', expectedContext);
-            });
-        });
-        describe('operands: measure and number', () => {
-            const expectedContext = {
-                '[measure1]': sampleMeasure1,
-            };
-            const numberOperand = 10;
-            test('measureFactory.add()', () => {
-                const m = measureFactory.add(sampleMeasure1, numberOperand, sampleMeasureName, true);
-                verifyCalculatedMeasure(m, `([measure1]+${numberOperand})`, expectedContext);
-            });
-            test('measureFactory.subtract()', () => {
-                const m = measureFactory.subtract(sampleMeasure1, numberOperand, sampleMeasureName, true);
-                verifyCalculatedMeasure(m, `([measure1]-${numberOperand})`, expectedContext);
-            });
-            test('measureFactory.multiply()', () => {
-                const m = measureFactory.multiply(sampleMeasure1, numberOperand, sampleMeasureName, true);
-                verifyCalculatedMeasure(m, `([measure1]*${numberOperand})`, expectedContext);
-            });
-            test('measureFactory.divide()', () => {
-                const m = measureFactory.divide(sampleMeasure1, numberOperand, sampleMeasureName, true);
-                verifyCalculatedMeasure(m, `([measure1]/${numberOperand})`, expectedContext);
-            });
-        });
-    });
-    describe('rank formula function', () => {
-        test('measureFactory.rank()', () => {
-            const groupByAttribute = new attributes_js_1.DimensionalAttribute('Age Range', '[Commerce.Age Range]');
-            const m = measureFactory.rank(sampleMeasure1, sampleMeasureName, measureFactory.RankingSortTypes.Descending, measureFactory.RankingTypes.Dense, [groupByAttribute]);
-            verifyCalculatedMeasure(m, 'rank([measure1],DESC,1223,[AgeRange])', {
-                '[measure1]': sampleMeasure1,
-                '[AgeRange]': groupByAttribute,
-            });
-        });
-    });
-    describe('measuredValue formula function', () => {
-        test('measureFactory.measuredValue()', () => {
-            const textDimension = (0, dimensions_js_1.createDimension)({
-                name: 'Age Range',
-                type: 'textdimension',
-                expression: '[Commerce.Age Range]',
-            });
-            const filter = filterFactory.equals(textDimension, '65+');
-            const m = measureFactory.measuredValue(sampleMeasure1, [filter], sampleMeasureName);
-            verifyCalculatedMeasure(m, `([measure1],${getContextName(filter)})`, {
-                '[measure1]': sampleMeasure1,
-                [getContextName(filter)]: filter,
-            });
-        });
-    });
-    describe('advanced analytics functions', () => {
-        test('measureFactory.trend() with no options', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.trend(m);
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    title: 'sum Cost Trend',
-                    formula: 'trend([sumCost])',
-                    context: {
-                        '[sumCost]': {
-                            title: 'sum Cost',
-                            dim: '[Commerce.Cost]',
-                            datatype: 'numeric',
-                            agg: 'sum',
-                        },
-                    },
-                },
-            });
-        });
-        test('measureFactory.trend() with modelType=advancedSmoothing', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.trend(m, 'Trend', {
-                modelType: 'advancedSmoothing',
-                ignoreAnomalies: true,
-            });
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    context: {
-                        '[sumCost]': {
-                            agg: 'sum',
-                            datatype: 'numeric',
-                            dim: '[Commerce.Cost]',
-                            title: 'sum Cost',
-                        },
-                    },
-                    formula: 'trend([sumCost], "modelType=smooth","ignoreAnomalies=true")',
-                    title: 'Trend',
-                },
-            });
-        });
-        test('measureFactory.trend() with modelType=localEstimates', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.trend(m, 'Trend', {
-                modelType: 'localEstimates',
-            });
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    context: {
-                        '[sumCost]': {
-                            agg: 'sum',
-                            datatype: 'numeric',
-                            dim: '[Commerce.Cost]',
-                            title: 'sum Cost',
-                        },
-                    },
-                    formula: 'trend([sumCost], "modelType=local")',
-                    title: 'Trend',
-                },
-            });
-        });
-        test('measureFactory.forecast() with no options', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.forecast(m);
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    formula: 'forecast([sumCost], "forecastHorizon=3")',
-                    title: 'sum Cost Forecast',
-                    context: {
-                        '[sumCost]': {
-                            title: 'sum Cost',
-                            dim: '[Commerce.Cost]',
-                            datatype: 'numeric',
-                            agg: 'sum',
-                        },
-                    },
-                },
-            });
-        });
-        test('measureFactory.forecast() with only modelType', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.forecast(m, 'Forecast', {
-                modelType: 'holtWinters',
-            });
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    formula: 'forecast([sumCost], "forecastHorizon=3","modelType=holtWinters")',
-                    title: 'Forecast',
-                    context: {
-                        '[sumCost]': {
-                            title: 'sum Cost',
-                            dim: '[Commerce.Cost]',
-                            datatype: 'numeric',
-                            agg: 'sum',
-                        },
-                    },
-                },
-            });
-        });
-        test('measureFactory.forecast() with all options', () => {
-            const m = measureFactory.sum(sampleAttribute);
-            const mTrend = measureFactory.forecast(m, 'Forecast', {
-                forecastHorizon: 6,
-                modelType: 'holtWinters',
-                startDate: new Date('2023-01-01'),
-                endDate: new Date('2023-06-01'),
-                confidenceInterval: 0.9,
-                lowerBound: 1000,
-                upperBound: 100000,
-                roundToInt: true,
-            });
-            expect(mTrend.jaql()).toStrictEqual({
-                jaql: {
-                    formula: 'forecast([sumCost], "forecastHorizon=6","modelType=holtWinters","startDate=2023-01-01T00:00:00","endDate=2023-06-01T00:00:00","confidenceInterval=0.9","lowerBound=1000","upperBound=100000","roundToInt=true")',
-                    title: 'Forecast',
-                    context: {
-                        '[sumCost]': {
-                            title: 'sum Cost',
-                            dim: '[Commerce.Cost]',
-                            datatype: 'numeric',
-                            agg: 'sum',
-                        },
-                    },
-                },
-            });
-        });
-    });
-    test('measureFactory.forecast() with ISO string dates', () => {
-        const m = measureFactory.sum(sampleAttribute);
-        const mTrend = measureFactory.forecast(m, 'Forecast', {
-            forecastHorizon: 6,
-            modelType: 'holtWinters',
-            startDate: '2023-01-01',
-            endDate: '2023-06-01',
-            confidenceInterval: 0.9,
-            lowerBound: 1000,
-            upperBound: 100000,
-            roundToInt: true,
-        });
-        expect(mTrend.jaql()).toStrictEqual({
-            jaql: {
-                formula: 'forecast([sumCost], "forecastHorizon=6","modelType=holtWinters","startDate=2023-01-01T00:00:00","endDate=2023-06-01T00:00:00","confidenceInterval=0.9","lowerBound=1000","upperBound=100000","roundToInt=true")',
-                title: 'Forecast',
-                context: {
-                    '[sumCost]': {
-                        title: 'sum Cost',
-                        dim: '[Commerce.Cost]',
-                        datatype: 'numeric',
-                        agg: 'sum',
-                    },
-                },
-            },
-        });
-    });
-    describe('measureFactory.customFormula()', () => {
-        test('with attribute and measure', () => {
-            const m = measureFactory.customFormula('Total Attribute', 'SUM([Attribute]) - [Average Measure]', {
-                Attribute: sampleAttribute,
-                'Average Measure': sampleMeasure2,
-            });
-            expect(m.jaql()).toStrictEqual({
-                jaql: {
-                    context: {
-                        '[Attribute]': {
-                            datatype: 'numeric',
-                            dim: '[Commerce.Cost]',
-                            title: 'Cost',
-                        },
-                        '[Average Measure]': {
-                            agg: 'avg',
-                            datatype: 'numeric',
-                            dim: '[Commerce.Cost]',
-                            title: 'measure 2',
-                        },
-                    },
-                    formula: 'SUM([Attribute]) - [Average Measure]',
-                    title: 'Total Attribute',
-                },
-            });
-        });
-        test('with nested formula', () => {
-            const nestedMeasure = measureFactory.customFormula('Total Attribute', 'SUM([Attribute]) - [Average Measure]', {
-                Attribute: sampleAttribute,
-                'Average Measure': sampleMeasure2,
-            });
-            const m = measureFactory.customFormula('Nested formula', 'RANK([Nested], "ASC", "1224")', {
-                Nested: nestedMeasure,
-            });
-            expect(m.jaql()).toStrictEqual({
-                jaql: {
-                    context: {
-                        '[Nested]': {
-                            context: {
-                                '[Attribute]': {
-                                    datatype: 'numeric',
-                                    dim: '[Commerce.Cost]',
-                                    title: 'Cost',
-                                },
-                                '[Average Measure]': {
-                                    agg: 'avg',
-                                    datatype: 'numeric',
-                                    dim: '[Commerce.Cost]',
-                                    title: 'measure 2',
-                                },
-                            },
-                            formula: 'SUM([Attribute]) - [Average Measure]',
-                            title: 'Total Attribute',
-                        },
-                    },
-                    formula: 'RANK([Nested], "ASC", "1224")',
-                    title: 'Nested formula',
-                },
-            });
-        });
-    });
-});

package/dist/cjs/dimensional-model/measures/measures.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cjs/dimensional-model/measures/measures.test.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-const measures_js_1 = require("./measures.js");
-const attributes_js_1 = require("../attributes.js");
-const types_js_1 = require("../types.js");
-describe('Measures jaql preparations', () => {
-    it('must prepare simple measure jaql', () => {
-        const result = {
-            jaql: { title: 'Cost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
-        };
-        const measure = new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum');
-        const jaql = measure.jaql();
-        expect(jaql).toStrictEqual(result);
-    });
-    it('must prepare constant as jaql', () => {
-        const result = {
-            jaql: {
-                title: '0',
-                formula: '0',
-                context: {},
-            },
-        };
-        const measure = new measures_js_1.DimensionalCalculatedMeasure('0', '0', {});
-        const jaql = measure.jaql();
-        expect(jaql).toStrictEqual(result);
-    });
-    it('must prepare calculated measure jaql', () => {
-        const result = {
-            jaql: {
-                title: 'sum([Cost] + [Total Revenue])',
-                formula: 'sum([M1] + [M2])',
-                context: {
-                    '[M1]': { title: 'Revenue', agg: 'sum', dim: '[Commerce.Revenue]', datatype: 'numeric' },
-                    '[M2]': { title: 'Cost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
-                },
-            },
-        };
-        const measure = new measures_js_1.DimensionalCalculatedMeasure('sum([Cost] + [Total Revenue])', 'sum([M1] + [M2])', {
-            '[M1]': new measures_js_1.DimensionalBaseMeasure('Revenue', new attributes_js_1.DimensionalAttribute('[Commerce.Revenue]', '[Commerce.Revenue]', 'numeric-attribute'), 'sum'),
-            '[M2]': new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum'),
-        });
-        const jaql = measure.jaql();
-        expect(jaql).toStrictEqual(result);
-    });
-    it('must prepare template measure jaql', () => {
-        const result = {
-            jaql: { title: 'sum CommerceCost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
-        };
-        const measure = new measures_js_1.DimensionalMeasureTemplate('Count', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'));
-        const jaql = measure.jaql();
-        expect(jaql).toStrictEqual(result);
-    });
-});
-describe('Measures aggregation transformations', () => {
-    const aggregationTypesMapping = {
-        [types_js_1.AggregationTypes.Sum]: 'sum',
-        [types_js_1.AggregationTypes.Average]: 'avg',
-        [types_js_1.AggregationTypes.Min]: 'min',
-        [types_js_1.AggregationTypes.Max]: 'max',
-        [types_js_1.AggregationTypes.Count]: 'countduplicates',
-        [types_js_1.AggregationTypes.CountDistinct]: 'count',
-        [types_js_1.AggregationTypes.Median]: 'median',
-        [types_js_1.AggregationTypes.Variance]: 'var',
-        [types_js_1.AggregationTypes.StandardDeviation]: 'stdev',
-    };
-    it('should correctly extract aggregation from jaql', () => {
-        Object.entries(aggregationTypesMapping).forEach(([aggType, jaqlAggType]) => {
-            expect(measures_js_1.DimensionalBaseMeasure.aggregationFromJAQL(jaqlAggType)).toEqual(aggType);
-        });
-    });
-    it('should correctly convert aggregation to jaql aggregation type', () => {
-        Object.entries(aggregationTypesMapping).forEach(([aggType, jaqlAggType]) => {
-            expect(measures_js_1.DimensionalBaseMeasure.aggregationToJAQL(aggType)).toEqual(jaqlAggType);
-        });
-    });
-});

package/dist/cjs/dimensional-model/simple-column-types.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cjs/dimensional-model/simple-column-types.test.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const simple_column_types_js_1 = require("./simple-column-types.js");
-const typeMap = {
-    number: [
-        // INTEGER
-        '__int4',
-        '__int8',
-        'int',
-        'tinyint',
-        'bigint',
-        'int2',
-        'int4',
-        'int8',
-        'smallint',
-        'mediumint',
-        'serial',
-        'integer',
-        'byteint',
-        'int64',
-        // DECIMAL
-        'basemeasure',
-        'calculatedmeasure',
-        'float',
-        'float4',
-        'float8',
-        'double precision',
-        'double',
-        'numeric',
-        'decimal',
-        'real',
-        'number',
-        'float64',
-        // OTHER
-        'numeric-attribute',
-    ],
-    text: [
-        'textdimension',
-        'string',
-        'varchar',
-        'text',
-        'ntext',
-        'char',
-        'character',
-        'character varying',
-        'smalltext',
-        'nchar',
-        'nvarchar',
-        'json',
-        'jsonb',
-        'object',
-        'text-attribute',
-        'RANDOM_TEXT',
-    ],
-    datetime: [
-        'datelevel',
-        'date',
-        'time',
-        'datetime',
-        'timestamp without time zone',
-        'timestamp',
-        'timestamp with time zone',
-        'timestamp(6)',
-        'timestamp_tz',
-        'timestamp_ntz',
-        'timestamp_ltz',
-        'timestampltz',
-        'timestampntz',
-        'timestamptz',
-        'datetime64[ns]',
-        'timewithtimezone',
-        'timestampwithtimezone',
-        'timestamp_with_timezone',
-    ],
-    boolean: ['bool', 'boolean', 'bit', 'logical'],
-};
-describe('simpleColumnType', () => {
-    it('should return correct type', () => {
-        Object.entries(typeMap).forEach(([outputType, inputTypes]) => {
-            inputTypes.forEach((inputType) => {
-                expect((0, simple_column_types_js_1.simpleColumnType)(inputType)).toBe(outputType);
-            });
-        });
-    });
-});

package/dist/cjs/dimensional-model/types.test.d.ts

@@ -1 +0,0 @@
-export {};