mdt-charts 1.15.7 → 1.16.1

package/lib/engine/cardsNotation/card/card.js

@@ -1,104 +0,0 @@
-import { FontResizer } from "../../helpers/fontResizer/fontResizer";
-import { NamesHelper } from "../../helpers/namesHelper";
-import { CardChange } from "./cardChange";
-import { CardElementsStyler } from "./cardElementsStyler";
-import { CardService } from "./cardService";
-export class CardChart {
-    constructor() {
-        this.cardValueCssClass = NamesHelper.getClassName("card-value");
-        this.cardContentBlockCssClass = NamesHelper.getClassName("card-content");
-        this.styler = new CardElementsStyler();
-    }
-    render(block, options, data, canvasOptions) {
-        const parent = block.html.getBlock();
-        const dataRow = data[options.data.dataSource][0];
-        const wrapper = this.renderCardWrapper(parent);
-        this.renderContentBlock(wrapper, options.color);
-        this.setContentFontSize(this.cardContentElement, canvasOptions);
-        this.renderHeaderBlock(this.cardContentElement, {
-            title: options.title,
-            icon: options.icon
-        });
-        if (options.description)
-            this.renderDescriptionBlock(this.cardContentElement, options.description);
-        this.renderValueBlock(this.cardContentElement, CardService.getValueContentFromDataSource(Object.assign(Object.assign({}, options.value), { dataSetName: options.data.dataSource }), data));
-        if (options.change) {
-            this.changeBlock = new CardChange();
-            this.changeBlock.render(this.cardContentElement, options.change, dataRow);
-        }
-    }
-    updateData(options, data) {
-        var _a;
-        const dataRow = data[options.data.dataSource][0];
-        this.setValueContent(CardService.getValueContentFromDataSource(Object.assign(Object.assign({}, options.value), { dataSetName: options.data.dataSource }), data));
-        this.updateValueBlockStyle();
-        this.setContentColor(options.color);
-        (_a = this.changeBlock) === null || _a === void 0 ? void 0 : _a.update(options.change, dataRow);
-    }
-    renderCardWrapper(parent) {
-        return parent.append("div")
-            .classed(this.cardContentBlockCssClass, true);
-    }
-    renderContentBlock(wrapper, color) {
-        this.cardContentElement = wrapper.append("div")
-            .classed(NamesHelper.getClassName("card-content"), true);
-        this.setContentColor(color);
-    }
-    setContentColor(color) {
-        this.cardContentElement.style("color", color);
-    }
-    setContentFontSize(contentBlock, canvasOptions) {
-        const fontSize = Math.floor(Math.min(canvasOptions.cardSize.height, canvasOptions.cardSize.width) / 10);
-        contentBlock.style("font-size", `${fontSize}px`);
-    }
-    renderHeaderBlock(contentBlock, options) {
-        const header = contentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-header"), true);
-        if (options.icon)
-            this.appendIcon(header, options.icon);
-        this.appendTitle(header, options.title);
-    }
-    appendTitle(headerBlock, textContent) {
-        headerBlock.append("h3")
-            .classed(NamesHelper.getClassName("card-title"), true)
-            .text(textContent)
-            .attr("title", textContent);
-    }
-    appendIcon(headerBlock, icon) {
-        const iconEl = icon();
-        headerBlock.append("div")
-            .classed(NamesHelper.getClassName("card-icon"), true)
-            .node()
-            .appendChild(iconEl);
-    }
-    renderDescriptionBlock(contentBlock, textContent) {
-        const wrapper = contentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-description-wrapper"), true);
-        wrapper.append("p")
-            .classed(NamesHelper.getClassName("card-description"), true)
-            .text(textContent)
-            .attr("title", textContent);
-    }
-    renderValueBlock(contentBlock, value) {
-        const wrapper = contentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-value-wrapper"), true);
-        this.valueContentElement = wrapper.append("div")
-            .classed(NamesHelper.getClassName("card-value-block"), true)
-            .append("span")
-            .classed(this.cardValueCssClass, true);
-        this.setValueContent(value);
-        this.updateValueBlockStyle();
-    }
-    updateValueBlockStyle() {
-        this.styler.setValueBlockFontSize(this.valueContentElement);
-        FontResizer.setSize(this.valueContentElement.node(), {
-            elWrapper: this.cardContentElement.node(),
-            unit: "em",
-            smallestFontSize: 0.5,
-            step: 0.1
-        });
-    }
-    setValueContent(value) {
-        this.valueContentElement.text(value);
-    }
-}

package/lib/engine/cardsNotation/card/cardChange.d.ts

@@ -1,21 +0,0 @@
-import { MdtChartsDataRow } from "../../../config/config";
-import { CardsChangeModel } from "../../../model/model";
-import { CardChildElement } from "./card";
-export declare class CardChange {
-    private wrapper;
-    private iconBlock;
-    private valueContentBlock;
-    private contentBlock;
-    render(contentBlock: CardChildElement, options: CardsChangeModel, dataRow: MdtChartsDataRow): void;
-    update(options: CardsChangeModel, dataRow: MdtChartsDataRow): void;
-    private renderWrapper;
-    private setColor;
-    private renderContentBlock;
-    private renderContentItems;
-    private renderContentItem;
-    private renderIcon;
-    private renderIconEl;
-    private renderValue;
-    private renderDescription;
-    private setValueContent;
-}

package/lib/engine/cardsNotation/card/cardChange.js

@@ -1,76 +0,0 @@
-import { NamesHelper } from "../../helpers/namesHelper";
-import { CardService } from "./cardService";
-export class CardChange {
-    render(contentBlock, options, dataRow) {
-        this.wrapper = this.renderWrapper(contentBlock);
-        this.setColor(this.wrapper, options);
-        this.renderContentBlock(this.wrapper);
-        this.renderContentItems(this.contentBlock, options, dataRow);
-    }
-    update(options, dataRow) {
-        this.setColor(this.wrapper, options);
-        this.setValueContent(CardService.getValueContentFromRow(options.value, dataRow), options.valuePrefix);
-        if (options.icon) {
-            if (this.iconBlock) {
-                this.iconBlock.html("");
-                this.renderIconEl(options.icon);
-            }
-            else {
-                this.renderIcon(this.contentBlock, options.icon);
-            }
-        }
-    }
-    renderWrapper(contentBlock) {
-        return contentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-change-wrapper"), true);
-    }
-    setColor(wrapper, options) {
-        wrapper.style("color", options.color);
-    }
-    renderContentBlock(wrapper) {
-        this.contentBlock = wrapper.append("div")
-            .classed(NamesHelper.getClassName("card-change-content"), true);
-    }
-    renderContentItems(contentBlock, options, dataRow) {
-        if (options.icon)
-            this.renderIcon(this.renderContentItem(contentBlock), options.icon);
-        this.renderValue(this.renderContentItem(contentBlock), CardService.getValueContentFromRow(options.value, dataRow), options.valuePrefix);
-        if (options.description)
-            this.renderDescription(this.renderContentItem(contentBlock, NamesHelper.getClassName("card-change-description-item")), options.description);
-    }
-    renderContentItem(contentBlock, cssClass) {
-        const item = contentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-change-content-item"), true);
-        if (cssClass)
-            item.classed(cssClass, true);
-        return item;
-    }
-    renderIcon(parentBlock, icon) {
-        this.iconBlock = parentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-change-icon"), true);
-        this.renderIconEl(icon);
-    }
-    renderIconEl(icon) {
-        const iconEl = icon();
-        this.iconBlock
-            .node()
-            .appendChild(iconEl);
-    }
-    renderValue(parentBlock, value, prefix) {
-        this.valueContentBlock = parentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-change-value"), true)
-            .append("span");
-        this.setValueContent(value, prefix);
-    }
-    renderDescription(parentBlock, textContent) {
-        return parentBlock.append("div")
-            .classed(NamesHelper.getClassName("card-change-description-wrapper"), true)
-            .append("span")
-            .classed(NamesHelper.getClassName("card-change-description"), true)
-            .text(textContent)
-            .attr("title", textContent);
-    }
-    setValueContent(textContent, prefix) {
-        this.valueContentBlock.text(prefix + textContent);
-    }
-}

package/lib/engine/cardsNotation/card/cardElementsStyler.d.ts

@@ -1,6 +0,0 @@
-import { CardChildElement } from "./card";
-export declare class CardElementsStyler {
-    private readonly cardValueFontSize;
-    setValueBlockFontSize(valueBlock: CardChildElement): void;
-    private setFontSize;
-}

package/lib/engine/cardsNotation/card/cardElementsStyler.js

@@ -1,11 +0,0 @@
-export class CardElementsStyler {
-    constructor() {
-        this.cardValueFontSize = "2em";
-    }
-    setValueBlockFontSize(valueBlock) {
-        this.setFontSize(valueBlock, this.cardValueFontSize);
-    }
-    setFontSize(cardElement, value) {
-        cardElement.style("font-size", value);
-    }
-}

package/lib/engine/cardsNotation/card/cardService.d.ts

@@ -1,11 +0,0 @@
-import { MdtChartsCardValue, MdtChartsDataRow, MdtChartsDataSource } from "../../../config/config";
-import { CardValueContent } from "./card";
-interface ValueContentGetterOptions extends MdtChartsCardValue {
-    dataSetName: string;
-}
-export declare class CardServiceClass {
-    getValueContentFromDataSource(valueOptions: ValueContentGetterOptions, data: MdtChartsDataSource): CardValueContent;
-    getValueContentFromRow(valueOptions: MdtChartsCardValue, dataRow: MdtChartsDataRow): string;
-}
-export declare const CardService: CardServiceClass;
-export {};

package/lib/engine/cardsNotation/card/cardService.js

@@ -1,12 +0,0 @@
-import { ValueFormatter } from "../../valueFormatter";
-export class CardServiceClass {
-    getValueContentFromDataSource(valueOptions, data) {
-        const dataRow = data[valueOptions.dataSetName][0];
-        return this.getValueContentFromRow(valueOptions, dataRow);
-    }
-    getValueContentFromRow(valueOptions, dataRow) {
-        const value = dataRow[valueOptions.name];
-        return ValueFormatter.formatField(valueOptions.format, value);
-    }
-}
-export const CardService = new CardServiceClass();

package/lib/engine/cardsNotation/cardsManager.d.ts

@@ -1,11 +0,0 @@
-import { MdtChartsDataSource } from "../../config/config";
-import { CardsOptionsModel, Model } from "../../model/model";
-import { Block } from "../block/block";
-import { ChartContentManager } from "../contentManager/contentManagerFactory";
-import { Engine } from "../engine";
-export declare class CardsManager implements ChartContentManager {
-    private chart;
-    render(engine: Engine, model: Model<CardsOptionsModel>): void;
-    updateData(block: Block, model: Model<CardsOptionsModel>, newData: MdtChartsDataSource): void;
-    updateColors(block: Block, model: Model<CardsOptionsModel>): void;
-}

package/lib/engine/cardsNotation/cardsManager.js

@@ -1,14 +0,0 @@
-import { CardChart } from "./card/card";
-export class CardsManager {
-    render(engine, model) {
-        engine.block.html.render();
-        this.chart = new CardChart();
-        this.chart.render(engine.block, model.options, engine.data, { cardSize: model.blockCanvas.size });
-    }
-    updateData(block, model, newData) {
-        this.chart.updateData(model.options, newData);
-    }
-    updateColors(block, model) {
-        //TODO: implement
-    }
-}

package/lib/engine/intervalNotation/gantt.d.ts

@@ -1,10 +0,0 @@
-import { MdtChartsDataRow } from '../../config/config';
-import { BarChartSettings, BlockMargin, IntervalChartModel, OptionsModelData, Orient } from "../../model/model";
-import { Block } from "../block/block";
-import { Scales } from "../features/scale/scale";
-export declare class Gantt {
-    private static readonly ganttItemClass;
-    static render(block: Block, data: MdtChartsDataRow[], dataOptions: OptionsModelData, scales: Scales, margin: BlockMargin, keyAxisOrient: Orient, chart: IntervalChartModel, barSettings: BarChartSettings): void;
-    private static fillItemsAttrs;
-    private static getItemsAttrsByKeyOrient;
-}

package/lib/engine/intervalNotation/gantt.js

@@ -1,62 +0,0 @@
-import { Scale } from "../features/scale/scale";
-import { DomHelper } from '../helpers/domHelper';
-export class Gantt {
-    static render(block, data, dataOptions, scales, margin, keyAxisOrient, chart, barSettings) {
-        const ganttItems = block.svg.getChartBlock()
-            .selectAll(`.${this.ganttItemClass}`)
-            .data(data)
-            .enter()
-            .append('rect')
-            .attr('class', this.ganttItemClass)
-            .style('clip-path', `url(#${block.svg.getClipPathId()})`);
-        const itemsAttrs = this.getItemsAttrsByKeyOrient(keyAxisOrient, scales, margin, dataOptions.keyField.name, chart.data.valueField1.name, chart.data.valueField2.name, barSettings);
-        this.fillItemsAttrs(ganttItems, itemsAttrs);
-        DomHelper.setCssClasses(ganttItems, chart.cssClasses);
-        DomHelper.setChartStyle(ganttItems, chart.style, 0, 'fill');
-    }
-    static fillItemsAttrs(ganttItems, attrs) {
-        ganttItems
-            .attr('x', d => attrs.x(d))
-            .attr('y', d => attrs.y(d))
-            .attr('width', d => attrs.width(d))
-            .attr('height', d => attrs.height(d));
-    }
-    static getItemsAttrsByKeyOrient(axisOrient, scales, margin, keyField, valueField1, valueField2, barSettings) {
-        const attrs = {
-            x: null,
-            y: null,
-            width: null,
-            height: null
-        };
-        const itemSize = Scale.getScaleBandWidth(scales.key) > barSettings.maxBarWidth
-            ? barSettings.maxBarWidth
-            : Scale.getScaleBandWidth(scales.key);
-        const sizeDiff = (Scale.getScaleBandWidth(scales.key) - itemSize) / 2;
-        if (axisOrient === 'top' || axisOrient === 'bottom') {
-            attrs.x = d => scales.key(d[keyField]) + margin.left + sizeDiff;
-            attrs.width = d => itemSize;
-        }
-        if (axisOrient === 'left' || axisOrient === 'right') {
-            attrs.y = d => scales.key(d[keyField]) + margin.top + sizeDiff;
-            attrs.height = d => itemSize;
-        }
-        if (axisOrient === 'top') {
-            attrs.y = d => scales.value(d[valueField1]) + margin.top;
-            attrs.height = d => scales.value(d[valueField2]) - scales.value(d[valueField1]);
-        }
-        else if (axisOrient === 'bottom') {
-            attrs.y = d => scales.value(d[valueField2]) + margin.top;
-            attrs.height = d => scales.value(d[valueField1]) - scales.value(d[valueField2]);
-        }
-        else if (axisOrient === 'left') {
-            attrs.x = d => scales.value(d[valueField1]) + margin.left;
-            attrs.width = d => scales.value(d[valueField2]) - scales.value(d[valueField1]);
-        }
-        else if (axisOrient === 'right') {
-            attrs.x = d => scales.value(d[valueField2]) + margin.left;
-            attrs.width = d => scales.value(d[valueField1]) - scales.value(d[valueField2]);
-        }
-        return attrs;
-    }
-}
-Gantt.ganttItemClass = 'gantt-item';

package/lib/engine/intervalNotation/intervalManager.d.ts

@@ -1,7 +0,0 @@
-import { MdtChartsDataSource } from "../../config/config";
-import { Model } from "../../model/model";
-import { Block } from "../block/block";
-export declare class IntervalManager {
-    static render(block: Block, model: Model, data: MdtChartsDataSource): void;
-    private static renderCharts;
-}

package/lib/engine/intervalNotation/intervalManager.js

@@ -1,23 +0,0 @@
-import { Axis } from "../features/axis/axis";
-import { GridLine } from "../features/gridLine/gridLine";
-import { Scale } from "../features/scale/scale";
-import { Title } from "../features/title/title";
-import { Gantt } from "./gantt";
-export class IntervalManager {
-    static render(block, model, data) {
-        const options = model.options;
-        block.svg.render(model.blockCanvas.size);
-        const scales = Scale.getScales(options.scale.key, options.scale.value, options.chartSettings.bar);
-        Axis.render(block, scales, options.scale, options.axis, model.blockCanvas.size);
-        GridLine.render(block, options.additionalElements.gridLine.flag, options.axis, model.blockCanvas.size, model.chartBlock.margin, scales);
-        this.renderCharts(block, options.charts, scales, data, options.data, model.chartBlock.margin, options.axis.key.orient, options.chartSettings);
-        Title.render(block, options.title, model.otherComponents.titleBlock, model.blockCanvas.size);
-    }
-    static renderCharts(block, charts, scales, data, dataOptions, margin, keyAxisOrient, chartSettings) {
-        block.svg.renderChartsBlock();
-        charts.forEach(chart => {
-            if (chart.type === 'gantt')
-                Gantt.render(block, data[dataOptions.dataSource], dataOptions, scales, margin, keyAxisOrient, chart, chartSettings.bar);
-        });
-    }
-}

package/lib/model/dataManagerModel/notations/cardsDataManagerModel.d.ts

@@ -1,4 +0,0 @@
-import { ModelInstance } from "../../modelInstance/modelInstance";
-export declare class CardsDataManagerModel {
-    initDataScope(modelInstance: ModelInstance): void;
-}

package/lib/model/dataManagerModel/notations/cardsDataManagerModel.js

@@ -1,8 +0,0 @@
-export class CardsDataManagerModel {
-    initDataScope(modelInstance) {
-        modelInstance.dataModel.initScope({
-            allowableKeys: [],
-            hidedRecordsAmount: 0
-        });
-    }
-}

package/lib/model/notations/cards/cardsChangeService.d.ts

@@ -1,9 +0,0 @@
-import { MdtChartsCardsChange, MdtChartsDataRow } from "../../../config/config";
-import { CardsChangeModel } from "../../model";
-export declare class CardsChangeService {
-    getChangeModel(dataRow: MdtChartsDataRow, changeOptions: MdtChartsCardsChange): CardsChangeModel;
-    private getValuePrefix;
-    private getColor;
-    private getIcon;
-    private getOptionsByValue;
-}

package/lib/model/notations/cards/cardsChangeService.js

@@ -1,42 +0,0 @@
-import { ColorRangeManager } from "../../chartStyleModel/colorRange";
-import { DEFAULT_CARD_CHANGE_RANGE } from "./cardsModelService";
-export class CardsChangeService {
-    getChangeModel(dataRow, changeOptions) {
-        var _a;
-        if (!changeOptions || !((_a = changeOptions.value) === null || _a === void 0 ? void 0 : _a.name))
-            return void 0;
-        const value = dataRow[changeOptions.value.name];
-        return {
-            description: changeOptions.description,
-            value: Object.assign({}, changeOptions.value),
-            valuePrefix: this.getValuePrefix(value),
-            color: this.getColor(value, changeOptions.color),
-            icon: this.getIcon(value, changeOptions.icon)
-        };
-    }
-    getValuePrefix(value) {
-        const prefixes = {
-            aboveZero: "+",
-            belowZero: "",
-            equalZero: ""
-        };
-        return this.getOptionsByValue(value, prefixes);
-    }
-    getColor(changeValue, colorOptions) {
-        const range = (colorOptions === null || colorOptions === void 0 ? void 0 : colorOptions.length) ? colorOptions : DEFAULT_CARD_CHANGE_RANGE;
-        const rangeManager = new ColorRangeManager(range);
-        return rangeManager.getColorByValue(changeValue);
-    }
-    getIcon(changeValue, iconOptions) {
-        if (!iconOptions)
-            return void 0;
-        return this.getOptionsByValue(changeValue, iconOptions);
-    }
-    getOptionsByValue(value, optionsByValues) {
-        if (value < 0)
-            return optionsByValues.belowZero;
-        if (value > 0)
-            return optionsByValues.aboveZero;
-        return optionsByValues.equalZero;
-    }
-}

package/lib/model/notations/cards/cardsModel.d.ts

@@ -1,8 +0,0 @@
-import { MdtChartsCardsOptions } from "../../../config/config";
-import { CardsOptionsModel } from "../../model";
-import { ModelInstance } from "../../modelInstance/modelInstance";
-export declare class CardsModel {
-    private service;
-    getOptions(options: MdtChartsCardsOptions, modelInstance: ModelInstance): CardsOptionsModel;
-}
-export declare const CardsModelInstance: CardsModel;

package/lib/model/notations/cards/cardsModel.js

@@ -1,20 +0,0 @@
-import { CardsModelService } from "./cardsModelService";
-export class CardsModel {
-    constructor() {
-        this.service = new CardsModelService();
-    }
-    getOptions(options, modelInstance) {
-        return {
-            type: "card",
-            title: options.title,
-            description: options.description,
-            data: options.data,
-            tooltip: options.tooltip,
-            icon: options.icon,
-            color: this.service.getCardColor(options, modelInstance),
-            value: Object.assign({}, options.value),
-            change: this.service.getCardsChangeModel(options, modelInstance)
-        };
-    }
-}
-export const CardsModelInstance = new CardsModel();

package/lib/model/notations/cards/cardsModelService.d.ts

@@ -1,11 +0,0 @@
-import { MdtChartsCardOptionByValue, MdtChartsCardsOptions, MdtChartsColorName, MdtChartsColorRangeItem } from "../../../config/config";
-import { ModelInstance } from "../../modelInstance/modelInstance";
-export declare const DEFAULT_CARD_COLOR: MdtChartsColorName;
-export declare const DEFAULT_CARD_CHANGE_COLOR: MdtChartsCardOptionByValue<MdtChartsColorName>;
-export declare const DEFAULT_CARD_CHANGE_RANGE: MdtChartsColorRangeItem[];
-export declare class CardsModelService {
-    private changeService;
-    getCardColor(options: MdtChartsCardsOptions, modelInstance: ModelInstance): MdtChartsColorName;
-    getCardsChangeModel(options: MdtChartsCardsOptions, modelInstance: ModelInstance): import("../../model").CardsChangeModel;
-}
-export declare function getCardColor(value: number | string, colorRange: MdtChartsColorRangeItem[]): string;

package/lib/model/notations/cards/cardsModelService.js

@@ -1,41 +0,0 @@
-import { ColorRangeManager } from "../../chartStyleModel/colorRange";
-import { CardsChangeService } from "./cardsChangeService";
-export const DEFAULT_CARD_COLOR = "#000";
-export const DEFAULT_CARD_CHANGE_COLOR = {
-    aboveZero: "#20b078",
-    equalZero: DEFAULT_CARD_COLOR,
-    belowZero: "#ff3131"
-};
-export const DEFAULT_CARD_CHANGE_RANGE = [
-    {
-        color: DEFAULT_CARD_CHANGE_COLOR.belowZero
-    },
-    {
-        color: DEFAULT_CARD_CHANGE_COLOR.equalZero,
-        value: 0
-    },
-    {
-        color: DEFAULT_CARD_CHANGE_COLOR.aboveZero,
-        value: 0
-    }
-];
-export class CardsModelService {
-    constructor() {
-        this.changeService = new CardsChangeService();
-    }
-    getCardColor(options, modelInstance) {
-        const data = modelInstance.dataModel.repository.getFirstRow();
-        const value = data[options.value.name];
-        return getCardColor(value, options.color);
-    }
-    getCardsChangeModel(options, modelInstance) {
-        const data = modelInstance.dataModel.repository.getFirstRow();
-        return this.changeService.getChangeModel(data, options.change);
-    }
-}
-export function getCardColor(value, colorRange) {
-    if (typeof value === "string" || !(colorRange === null || colorRange === void 0 ? void 0 : colorRange.length))
-        return DEFAULT_CARD_COLOR;
-    const rangeManager = new ColorRangeManager(colorRange);
-    return rangeManager.getColorByValue(value);
-}

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

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

package/lib/model/notations/intervalModel.js

@@ -1,95 +0,0 @@
-import { AxisModel } from "../featuresModel/axisModel";
-import { ChartStyleModelService } from "../chartStyleModel/chartStyleModel";
-import { DataManagerModel } from "../dataManagerModel/dataManagerModel";
-import { AxisType } from "../modelBuilder";
-import { TwoDimensionalModel } from "./twoDimensionalModel";
-export class IntervalModel {
-    static getOptions(options, designerConfig, modelInstance) {
-        const canvasModel = modelInstance.canvasModel;
-        const dataModelRep = modelInstance.dataModel.repository;
-        return {
-            legend: canvasModel.legendCanvas.getModel(),
-            title: options.title,
-            selectable: !!options.selectable,
-            orient: options.orientation,
-            scale: {
-                key: {
-                    domain: modelInstance.dataModel.getAllowableKeys(),
-                    range: {
-                        start: 0,
-                        end: 0
-                    },
-                    type: 'band',
-                    elementsAmount: 1
-                },
-                value: {
-                    domain: [],
-                    range: {
-                        start: 0,
-                        end: 0
-                    },
-                    type: 'datetime',
-                    formatter: null
-                }
-            },
-            axis: {
-                key: {
-                    type: 'key',
-                    orient: AxisModel.getAxisOrient(AxisType.Key, options.orientation, options.axis.key.position),
-                    translate: {
-                        translateX: AxisModel.getAxisTranslateX(AxisType.Key, options.orientation, options.axis.key.position, canvasModel),
-                        translateY: AxisModel.getAxisTranslateY(AxisType.Key, options.orientation, options.axis.key.position, canvasModel)
-                    },
-                    cssClass: 'key-axis',
-                    ticks: options.axis.key.ticks,
-                    labels: {
-                        maxSize: AxisModel.getLabelSizeLegacy(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'
-                    },
-                    visibility: options.axis.key.visibility
-                },
-                value: {
-                    type: 'value',
-                    orient: AxisModel.getAxisOrient(AxisType.Value, options.orientation, options.axis.value.position),
-                    translate: {
-                        translateX: AxisModel.getAxisTranslateX(AxisType.Value, options.orientation, options.axis.value.position, canvasModel),
-                        translateY: AxisModel.getAxisTranslateY(AxisType.Value, options.orientation, options.axis.value.position, canvasModel)
-                    },
-                    cssClass: 'value-axis',
-                    ticks: options.axis.value.ticks,
-                    labels: {
-                        maxSize: designerConfig.canvas.axisLabel.maxSize.main,
-                        position: 'straight',
-                        visible: true,
-                        defaultTooltip: true
-                    },
-                    visibility: options.axis.value.visibility
-                }
-            },
-            data: Object.assign({}, options.data),
-            type: options.type,
-            charts: this.getChartsModel(options.chart, designerConfig.chartStyle),
-            additionalElements: this.getAdditionalElements(options),
-            tooltip: options.tooltip,
-            chartSettings: TwoDimensionalModel.getChartsSettings(designerConfig.canvas.chartOptions, options.orientation)
-        };
-    }
-    static getAdditionalElements(options) {
-        return {
-            gridLine: options.additionalElements.gridLine
-        };
-    }
-    static getChartsModel(chart, chartStyleConfig) {
-        const chartsModel = [];
-        chartsModel.push({
-            type: chart.type,
-            data: Object.assign({}, chart.data),
-            tooltip: chart.tooltip,
-            cssClasses: ChartStyleModelService.getCssClasses(0),
-            style: ChartStyleModelService.getChartStyle(1, chartStyleConfig)
-        });
-        return chartsModel;
-    }
-}