mdt-charts 1.12.10 → 1.12.14

package/lib/model/model.d.ts

@@ -9,6 +9,7 @@ export declare type EmbeddedLabelTypeModel = "none" | "key" | "value";
 export declare type DataOptions = {
     [option: string]: any;
 };
+export declare type UnitsFromConfig = "%" | "px";
 export interface Model<O = TwoDimensionalOptionsModel | PolarOptionsModel | IntervalOptionsModel> {
     blockCanvas: BlockCanvas;
     chartBlock: ChartBlockModel;
@@ -148,7 +149,7 @@ export interface DonutAggregatorContent {
     value: string | number;
     title: string;
 }
-export declare type DonutThicknessUnit = "px" | "%";
+export declare type DonutThicknessUnit = UnitsFromConfig;
 export interface DonutThicknessOptions {
     min: number;
     max: number;
@@ -223,7 +224,6 @@ interface ComponentBlockModel {
 }
 export interface LegendBlockModel {
     coordinate: LegendCoordinate;
-    standartTooltip: boolean;
 }
 export interface LegendCoordinate {
     top: LegendCanvasCoordinate;

package/lib/model/modelBuilder.d.ts

@@ -13,4 +13,3 @@ export declare const CLASSES: {
 };
 export declare function assembleModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;
 export declare function getPreparedData(model: Model, data: MdtChartsDataSource, config: MdtChartsConfig): MdtChartsDataSource;
-export declare function getUpdatedModel(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig): Model;

package/lib/model/modelBuilder.js

@@ -1,4 +1,4 @@
-import { MarginModel } from './marginModel';
+import { MarginModel } from './margin/marginModel';
 import { TwoDimensionalModel } from './notations/twoDimensionalModel';
 import { PolarModel } from './notations/polar/polarModel';
 import { DataManagerModel } from './dataManagerModel/dataManagerModel';
@@ -30,16 +30,16 @@ function getChartBlockModel(modelInstance) {
         margin: modelInstance.canvasModel.getMargin()
     };
 }
-function getOptions(config, designerConfig, modelInstance, data) {
+function getOptions(config, designerConfig, modelInstance) {
     //TODO: migrate to polymorphism
     if (config.options.type === '2d') {
-        return TwoDimensionalModel.getOptions(config.options, designerConfig, data, modelInstance);
+        return TwoDimensionalModel.getOptions(config.options, designerConfig, modelInstance);
     }
     else if (config.options.type === 'polar') {
         return PolarModel.getOptions(config.options, designerConfig, modelInstance);
     }
     else if (config.options.type === 'interval') {
-        return IntervalModel.getOptions(config, designerConfig, modelInstance.canvasModel.getMargin(), modelInstance.dataModel.getScope(), data, modelInstance);
+        return IntervalModel.getOptions(config.options, designerConfig, modelInstance);
     }
 }
 function getDataSettings(dataScope, designerConfig) {
@@ -67,16 +67,14 @@ export function assembleModel(config, data, designerConfig) {
             dataSettings: null
         };
     resetFalsyValues(data, config.options.data.keyField.name);
-    const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, notation: config.options.type, title: config.options.title }, modelInstance);
+    const otherComponents = OtherComponentsModel.getOtherComponentsModel({ elementsOptions: designerConfig.elementsOptions, title: config.options.title }, modelInstance);
     MarginModel.initMargin(designerConfig, config, otherComponents, data, modelInstance);
     DataManagerModel.initDataScope(config, data, designerConfig, otherComponents.legendBlock, modelInstance);
-    const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
-    modelInstance.dataModel.repository.initScopedFullSource(preparedData);
     if (config.options.type === '2d' && config.options.axis.key.visibility)
-        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config, designerConfig, modelInstance.dataModel.getScope());
+        MarginModel.recalcMarginByVerticalAxisLabel(modelInstance, config.options, designerConfig);
     const blockCanvas = getBlockCanvas(config, modelInstance);
     const chartBlock = getChartBlockModel(modelInstance);
-    const options = getOptions(config, designerConfig, modelInstance, preparedData);
+    const options = getOptions(config, designerConfig, modelInstance);
     const dataSettings = getDataSettings(modelInstance.dataModel.getScope(), designerConfig);
     const transitions = getTransitions(designerConfig);
     modelInstance.canvasModel.roundMargin();
@@ -111,6 +109,3 @@ export function getPreparedData(model, data, config) {
     const preparedData = DataManagerModel.getPreparedData(data, model.dataSettings.scope.allowableKeys, config);
     return preparedData;
 }
-export function getUpdatedModel(config, data, designerConfig) {
-    return assembleModel(config, data, designerConfig);
-}

package/lib/model/notations/intervalModel.d.ts

@@ -1,9 +1,9 @@
-import { MdtChartsConfig, MdtChartsDataSource, MdtChartsIntervalOptions } from "../../config/config";
+import { MdtChartsIntervalOptions } from "../../config/config";
 import { DesignerConfig } from "../../designer/designerConfig";
-import { AdditionalElementsOptions, BlockMargin, DataScope, IntervalOptionsModel } from "../model";
+import { AdditionalElementsOptions, IntervalOptionsModel } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class IntervalModel {
-    static getOptions(config: MdtChartsConfig, designerConfig: DesignerConfig, margin: BlockMargin, dataScope: DataScope, data: MdtChartsDataSource, modelInstance: ModelInstance): IntervalOptionsModel;
+    static getOptions(options: MdtChartsIntervalOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): IntervalOptionsModel;
     static getAdditionalElements(options: MdtChartsIntervalOptions): AdditionalElementsOptions;
     private static getChartsModel;
 }

package/lib/model/notations/intervalModel.js

@@ -5,9 +5,9 @@ import { AxisType } from "../modelBuilder";
 import { ScaleModel, ScaleType } from "../featuresModel/scaleModel/scaleModel";
 import { TwoDimensionalModel } from "./twoDimensionalModel";
 export class IntervalModel {
-    static getOptions(config, designerConfig, margin, dataScope, data, modelInstance) {
-        const options = config.options;
+    static getOptions(options, designerConfig, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
+        const dataModelRep = modelInstance.dataModel.repository;
         return {
             legend: canvasModel.legendCanvas.getModel(),
             title: options.title,
@@ -15,7 +15,7 @@ export class IntervalModel {
             orient: options.orientation,
             scale: {
                 key: {
-                    domain: dataScope.allowableKeys,
+                    domain: modelInstance.dataModel.getAllowableKeys(),
                     range: {
                         start: 0,
                         end: ScaleModel.getRangePeek(ScaleType.Key, options.orientation, canvasModel)
@@ -24,7 +24,7 @@ export class IntervalModel {
                     elementsAmount: 1
                 },
                 value: {
-                    domain: ScaleModel.getDateValueDomain(data, options.chart, options.axis.key.position, options.data.dataSource),
+                    domain: ScaleModel.getDateValueDomain(dataModelRep.getScopedFullSource(), options.chart, options.axis.key.position, options.data.dataSource),
                     range: {
                         start: 0,
                         end: ScaleModel.getRangePeek(ScaleType.Value, options.orientation, canvasModel)
@@ -43,8 +43,8 @@ export class IntervalModel {
                     cssClass: 'key-axis',
                     ticks: options.axis.key.ticks,
                     labels: {
-                        maxSize: AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, data[options.data.dataSource].map(d => d[options.data.keyField.name])).width,
-                        position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(data, options.data.dataSource, options.data.keyField.name).length),
+                        maxSize: AxisModel.getLabelSize(designerConfig.canvas.axisLabel.maxSize.main, dataModelRep.getScopedRows().map(d => d[options.data.keyField.name])).width,
+                        position: AxisModel.getKeyAxisLabelPosition(canvasModel, DataManagerModel.getDataValuesByKeyField(dataModelRep.getScopedFullSource(), options.data.dataSource, options.data.keyField.name).length),
                         visible: true,
                         defaultTooltip: designerConfig.elementsOptions.tooltip.position === 'fixed'
                     },

package/lib/model/notations/polar/donut/donutAggregatorService.d.ts

@@ -9,4 +9,5 @@ export declare class DonutAggregatorService {
     getContent(aggregatorOptions: MdtChartsDonutAggregator, dataOptions: AggregatorServiceDataOptions): DonutAggregatorContent;
     private doesValueExist;
     private generateDefaultContent;
+    private getDefaultValue;
 }

package/lib/model/notations/polar/donut/donutAggregatorService.js

@@ -4,14 +4,25 @@ export class DonutAggregatorService {
         if (!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) || !dataOptions.rows)
             return this.generateDefaultContent(dataOptions);
         const content = aggregatorOptions.content({ data: dataOptions.rows });
-        if (this.doesValueExist(content.value) && content.title)
-            return content;
+        if (!content || (!this.doesValueExist(content.value) && !content.title))
+            return this.generateDefaultContent(dataOptions);
+        if (this.doesValueExist(content.value) && content.title) {
+            return {
+                title: content.title,
+                value: content.value
+            };
+        }
         if (!content.title && this.doesValueExist(content.value))
             return {
                 value: content.value,
                 title: AGGREGATOR_DEFAULT_TITLE
             };
-        return this.generateDefaultContent(dataOptions);
+        if (!this.doesValueExist(content.value) && content.title) {
+            return {
+                value: this.getDefaultValue(dataOptions),
+                title: content.title
+            };
+        }
     }
     doesValueExist(content) {
         return content != null;
@@ -19,7 +30,11 @@ export class DonutAggregatorService {
     generateDefaultContent(dataOptions) {
         return {
             title: AGGREGATOR_DEFAULT_TITLE,
-            value: dataOptions.rows ? dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0) : 0
+            value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
         };
     }
+    getDefaultValue(dataOptions) {
+        const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
+        return totalSumOfValues;
+    }
 }

package/lib/model/notations/polar/donut/donutThicknessService.d.ts

@@ -4,6 +4,4 @@ export declare class DonutThicknessService {
     private defaultUnit;
     getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
     valueToNumber(value: string | number): number;
-    private getUnitByValue;
-    private getLastUnitFromString;
 }

package/lib/model/notations/polar/donut/donutThicknessService.js

@@ -1,12 +1,13 @@
+import { getPxPercentUnitByValue } from "../../../helpers/unitsFromConfigReader";
 export class DonutThicknessService {
     constructor() {
         this.defaultUnit = "px";
     }
     getUnit(settingsFromConfig) {
         if (settingsFromConfig.value)
-            return this.getUnitByValue(settingsFromConfig.value);
-        const minUnit = this.getUnitByValue(settingsFromConfig.min);
-        const maxUnit = this.getUnitByValue(settingsFromConfig.max);
+            return getPxPercentUnitByValue(settingsFromConfig.value);
+        const minUnit = getPxPercentUnitByValue(settingsFromConfig.min);
+        const maxUnit = getPxPercentUnitByValue(settingsFromConfig.max);
         return minUnit === maxUnit ? minUnit : this.defaultUnit;
     }
     valueToNumber(value) {
@@ -14,17 +15,4 @@ export class DonutThicknessService {
             return value;
         return parseInt(value);
     }
-    getUnitByValue(value) {
-        if (typeof value !== "string")
-            return this.defaultUnit;
-        return this.getLastUnitFromString(value);
-    }
-    getLastUnitFromString(value) {
-        let resultUnit = this.defaultUnit;
-        ["%", "px"].forEach(unit => {
-            if (value.endsWith(unit))
-                resultUnit = unit;
-        });
-        return resultUnit;
-    }
 }

package/lib/model/notations/twoDimensionalModel.d.ts

@@ -1,9 +1,9 @@
-import { ChartOrientation, MdtChartsDataSource, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
+import { ChartOrientation, MdtChartsTwoDimensionalChart, MdtChartsTwoDimensionalOptions } from "../../config/config";
 import { BarOptionsCanvas, DesignerConfig } from "../../designer/designerConfig";
 import { TwoDimensionalOptionsModel, TwoDimChartElementsSettings } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export declare class TwoDimensionalModel {
-    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, data: MdtChartsDataSource, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
+    static getOptions(options: MdtChartsTwoDimensionalOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): TwoDimensionalOptionsModel;
     static getChartsEmbeddedLabelsFlag(charts: MdtChartsTwoDimensionalChart[], chartOrientation: ChartOrientation): boolean;
     /**
      * Сортирует список чартов в порядке: area - bar - line.

package/lib/model/notations/twoDimensionalModel.js

@@ -4,9 +4,10 @@ import { AxisModel } from "../featuresModel/axisModel";
 import { ScaleAxisRecalcer } from "../featuresModel/scaleModel/scaleAxisRecalcer";
 import { ScaleModel } from "../featuresModel/scaleModel/scaleModel";
 export class TwoDimensionalModel {
-    static getOptions(options, designerConfig, data, modelInstance) {
+    static getOptions(options, designerConfig, modelInstance) {
         const canvasModel = modelInstance.canvasModel;
-        const scaleMarginRecalcer = new ScaleAxisRecalcer(() => ScaleModel.getScaleLinear(options, data, canvasModel));
+        const dataModelRep = modelInstance.dataModel.repository;
+        const scaleMarginRecalcer = new ScaleAxisRecalcer(() => ScaleModel.getScaleLinear(options, dataModelRep.getScopedRows(), canvasModel));
         scaleMarginRecalcer.recalculateMargin(canvasModel, options.orientation, options.axis.key);
         const scaleValueInfo = scaleMarginRecalcer.getScaleValue();
         return {
@@ -19,7 +20,7 @@ export class TwoDimensionalModel {
                 value: scaleValueInfo.scale
             },
             axis: {
-                key: AxisModel.getKeyAxis(options, data, designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0)),
+                key: AxisModel.getKeyAxis(options, dataModelRep.getScopedFullSource(), designerConfig.canvas.axisLabel, canvasModel, designerConfig.elementsOptions.tooltip, () => scaleValueInfo.scaleFn(0)),
                 value: AxisModel.getValueAxis(options.orientation, options.axis.value, designerConfig.canvas.axisLabel, canvasModel)
             },
             type: options.type,

package/lib/style/charts-main.css

@@ -80,6 +80,8 @@
 }
 .legend-item-row > span {
     display: block;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 
 .legend-label {

package/lib/style/charts-main.less

@@ -80,6 +80,8 @@
 }
 .legend-item-row > span {
     display: block;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 
 .legend-label {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdt-charts",
-  "version": "1.12.10",
+  "version": "1.12.14",
   "description": "",
   "main": "lib/main.js",
   "scripts": {

package/tsconfig.production.json

@@ -18,6 +18,7 @@
         "node_modules",
         "**/__tests__/*",
         "src/playground/*",
-        "**/*Example.ts"
+        "**/*Example.ts",
+        "**/*.test.ts"
     ]
 }

package/lib/engine/features/tolltip/newTooltip/newTooltip.test.d.ts

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

package/lib/engine/features/tolltip/newTooltip/newTooltip.test.js

@@ -1,186 +0,0 @@
-import { NewTooltipServiceClass } from "./newTooltipService";
-const ignoredValue = 0;
-const ignoredBigvalue = 1000000;
-describe('newTooltipService', () => {
-    const getIgnoredSize = (big) => {
-        return {
-            height: big ? ignoredBigvalue : ignoredValue,
-            width: big ? ignoredBigvalue : ignoredValue
-        };
-    };
-    const getSizeWithOne = (key, value) => {
-        const size = getIgnoredSize();
-        size[key] = value;
-        return size;
-    };
-    const getPosWithOne = (key, value) => {
-        const coordinate = {
-            left: ignoredValue,
-            top: ignoredValue
-        };
-        coordinate[key] = value;
-        return coordinate;
-    };
-    const getBoundingWithOne = (key, value) => {
-        const blockBounding = {
-            left: ignoredValue,
-            bottom: ignoredValue,
-            height: ignoredValue,
-            top: ignoredValue,
-            width: ignoredValue
-        };
-        blockBounding[key] = value;
-        return blockBounding;
-    };
-    const service = new NewTooltipServiceClass();
-    describe('getTooltipByWindow with parentBlock', () => {
-        test('should return left point equal to `-(left of parent block)` if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", -50);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("left", 10);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(-blockBounding.left);
-        });
-        test('should return left point equal to left of preCoordinate if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("left", 10);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(preCoordinate.left);
-        });
-        test('should return left point equal to `(window width - tooltip width)` if right of tooltip is bigger', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 90);
-            const blockBounding = getBoundingWithOne("left", 30);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(-8); // 50 + 20 + 30 > 90 => 90 - 30 - 50 - scrollPad(18)
-        });
-        test('should return left point equal to left of preCoordinate if right of tooltip is less than window width', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 200);
-            const blockBounding = getBoundingWithOne("left", 30);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.left).toBe(preCoordinate.left); // 50 + 20 + 30 < 200
-        });
-        test('should return top point equal to `-(top of parent block)` if top of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", -40);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("top", -20);
-            let res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-            blockBounding.top = -60;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top); // 60 by blockBounding = 0 by window
-            blockBounding.top = -100;
-            preCoordinate.top = 20;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-            blockBounding.top = -10;
-            preCoordinate.top = 5;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(-blockBounding.top);
-        });
-        test('should return top point equal top of preCoordinate if top of tooltip is bigger', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", 20);
-            const windowSize = getIgnoredSize(true);
-            const blockBounding = getBoundingWithOne("top", 100);
-            let res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top);
-            preCoordinate.top = -99;
-            res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top);
-        });
-        test('should return top point equal to `(winHeight - tooltipHeight)` if bottom of tooltip is bigger than window height', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 200);
-            const blockBounding = {
-                left: ignoredValue,
-                bottom: 210,
-                height: 110,
-                top: 100,
-                width: ignoredValue
-            };
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(50); // 110 - 50 - (210 - 200)
-        });
-        test('should return top point equal to top of preCoordinate if bottom of tooltip is less than height of window', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 300);
-            const blockBounding = {
-                left: ignoredValue,
-                bottom: 210,
-                height: 110,
-                top: 100,
-                width: ignoredValue
-            };
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize, blockBounding);
-            expect(res.top).toBe(preCoordinate.top); // 90 + 50 + 100 < 300
-        });
-    });
-    describe('getTooltipByWindow without parentBlock', () => {
-        test('should return left point equal to 0 if left of tooltip is less', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", -50);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left === 0).toBe(true); // negative zero jest not matching with simple zero
-        });
-        test('should return left point equal to left of preCoordinate if left of tooltip is bigger than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(preCoordinate.left);
-        });
-        test('should return left point equal to `(window width - tooltip width)` if right of tooltip is bigger', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 60);
-            const windowSize = getSizeWithOne("width", 100);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(32); // 60 + 50 > 100 => 100 - 50 - scrollPad(18)
-        });
-        test('should return left point equal to left of preCoordinate if right of tooltip is less than window width', () => {
-            const tooltipBounding = getSizeWithOne("width", 50);
-            const preCoordinate = getPosWithOne("left", 20);
-            const windowSize = getSizeWithOne("width", 200);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.left).toBe(preCoordinate.left); // 50 + 20 < 200
-        });
-        test('should return top point equal to 0 if top of tooltip is less than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", -40);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top === 0).toBe(true);
-        });
-        test('should return top point equal top of preCoordinate if top of tooltip is bigger than 0', () => {
-            const tooltipBounding = getIgnoredSize();
-            const preCoordinate = getPosWithOne("top", 20);
-            const windowSize = getIgnoredSize(true);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(preCoordinate.top);
-        });
-        test('should return top point equal to `(winHeight - tooltipHeight)` if bottom of tooltip is bigger than window height', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 100);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(50); // 90 + 50 > 100 => 100 - 50
-        });
-        test('should return top point equal to top of preCoordinate if bottom of tooltip is less than height of window', () => {
-            const tooltipBounding = getSizeWithOne("height", 50);
-            const preCoordinate = getPosWithOne("top", 90);
-            const windowSize = getSizeWithOne("height", 300);
-            const res = service.getTooltipByWindow(tooltipBounding, preCoordinate, windowSize);
-            expect(res.top).toBe(preCoordinate.top); // 90 + 50 < 300
-        });
-    });
-});

package/lib/engine/twoDimensionalNotation/bar/stackedData/dataStacker.test.d.ts

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