mdt-charts 1.27.1 → 1.27.2

package/lib/engine/features/aggregator/aggregator.js

@@ -1,6 +1,6 @@
-import { interpolateNumber } from 'd3-interpolate';
-import { Helper } from '../../helpers/helper';
-import { ValueFormatter } from '../../valueFormatter';
+import { interpolateNumber } from "d3-interpolate";
+import { Helper } from "../../helpers/helper";
+import { ValueFormatter } from "../../valueFormatter";
 export class Aggregator {
     static render(block, valueField, innerRadius, translate, fontSize, settings) {
         const aggregator = this.buildConfig(valueField, settings);
@@ -23,17 +23,17 @@ export class Aggregator {
             const aggregatorObject = this.renderAggregatorObject(block, innerRadius, translate);
             const wrapper = this.renderWrapper(aggregatorObject);
             wrapper
-                .append('div')
-                .attr('class', this.aggregatorValueClass)
-                .attr('title', this.formatValue(aggregatorInfo.format, aggregatorInfo.value))
-                .style('text-align', 'center')
-                .style('font-size', `${fontSize}px`)
+                .append("div")
+                .attr("class", this.aggregatorValueClass)
+                .attr("title", this.formatValue(aggregatorInfo.format, aggregatorInfo.value))
+                .style("text-align", "center")
+                .style("font-size", `${fontSize}px`)
                 .text(this.formatValue(aggregatorInfo.format, aggregatorInfo.value));
             const titleBlock = wrapper
-                .append('div')
-                .attr('class', this.aggregatorTitleClass)
-                .attr('title', aggregatorInfo.name)
-                .style('text-align', 'center')
+                .append("div")
+                .attr("class", this.aggregatorTitleClass)
+                .attr("title", aggregatorInfo.name)
+                .style("text-align", "center")
                 .text(aggregatorInfo.name);
             this.setTitleFontSize(titleBlock, innerRadius);
             this.reCalculateAggregatorFontSize(aggregatorObject.node().getBoundingClientRect().width, block, aggregatorInfo.marginInPercent);
@@ -45,11 +45,9 @@ export class Aggregator {
         return ValueFormatter.formatField(format, value);
     }
     static updateText(block, newAggregator, withoutAnimation) {
-        const aggregatorObject = block.getSvg()
-            .select(`.${this.aggregatorObjectClass}`);
+        const aggregatorObject = block.getSvg().select(`.${this.aggregatorObjectClass}`);
         const thisClass = this;
-        const valueBlock = block.getSvg()
-            .select(`.${this.aggregatorValueClass}`);
+        const valueBlock = block.getSvg().select(`.${this.aggregatorValueClass}`);
         if (withoutAnimation) {
             valueBlock.text(this.formatValue(newAggregator.format, newAggregator.value));
             return;
@@ -60,53 +58,53 @@ export class Aggregator {
             .duration(block.transitionManager.durations.chartUpdate)
             .tween("text", function () {
             const newValue = typeof newAggregator.value === "string" ? parseFloat(newAggregator.value) : newAggregator.value;
-            const oldValue = Helper.parseFormattedToNumber(this.textContent, ',');
+            const oldValue = Helper.parseFormattedToNumber(this.textContent, ",");
             const precision = Helper.calcDigitsAfterDot(newValue);
             const interpolateFunc = interpolateNumber(oldValue, newValue);
-            return t => {
-                this.textContent = thisClass.formatValue(newAggregator.format, parseFloat((interpolateFunc(t)).toFixed(precision)));
+            return (t) => {
+                this.textContent = thisClass.formatValue(newAggregator.format, parseFloat(interpolateFunc(t).toFixed(precision)));
                 thisClass.reCalculateAggregatorFontSize(aggregatorObject.node().getBoundingClientRect().width, block, newAggregator.marginInPercent);
             };
         });
     }
     static reCalculateAggregatorFontSize(wrapperSize, block, pad) {
-        const aggregatorValue = block.getSvg()
-            .select(`.${this.aggregatorValueClass}`);
+        const aggregatorValue = block.getSvg().select(`.${this.aggregatorValueClass}`);
         const sizeCoefficient = 0.25;
         let fontSize = wrapperSize * sizeCoefficient;
-        aggregatorValue.style('font-size', `${fontSize}px`);
-        const margin = pad / 100 * wrapperSize;
+        aggregatorValue.style("font-size", `${fontSize}px`);
+        const margin = (pad / 100) * wrapperSize;
         while (aggregatorValue.node().getBoundingClientRect().width > wrapperSize - margin * 2 && fontSize > 12) {
-            aggregatorValue.style('font-size', `${fontSize -= 2}px`);
+            aggregatorValue.style("font-size", `${(fontSize -= 2)}px`);
         }
     }
     static setTitleFontSize(aggregatorTitle, innerRadius) {
         const sizeCoefficient = 0.15;
-        aggregatorTitle.style('font-size', `${Math.round(innerRadius * sizeCoefficient)}px`);
-        aggregatorTitle.style('max-height', `${sizeCoefficient * 100}%`);
+        aggregatorTitle.style("font-size", `${Math.round(innerRadius * sizeCoefficient)}px`);
+        aggregatorTitle.style("max-height", `${sizeCoefficient * 100}%`);
     }
     static renderAggregatorObject(block, innerRadius, translate) {
-        return block.getSvg()
-            .append('foreignObject')
-            .attr('class', this.aggregatorObjectClass)
-            .attr('transform-origin', 'center')
-            .attr('width', innerRadius * 2)
-            .attr('height', innerRadius * 2)
-            .attr('transform', `translate(${translate.x - innerRadius}, ${translate.y - innerRadius})`)
-            .style('pointer-events', `none`);
+        return block
+            .getSvg()
+            .append("foreignObject")
+            .attr("class", this.aggregatorObjectClass)
+            .attr("transform-origin", "center")
+            .attr("width", innerRadius * 2)
+            .attr("height", innerRadius * 2)
+            .attr("transform", `translate(${translate.x - innerRadius}, ${translate.y - innerRadius})`)
+            .style("pointer-events", `none`);
     }
     static renderWrapper(aggregatorObject) {
         return aggregatorObject
-            .append('xhtml:div')
-            .style('width', '100%')
-            .style('height', '100%')
-            .style('border-radius', '50%')
-            .style('display', 'flex')
-            .style('flex-direction', 'column')
-            .style('justify-content', 'center')
-            .style('align-items', 'center');
+            .append("xhtml:div")
+            .style("width", "100%")
+            .style("height", "100%")
+            .style("border-radius", "50%")
+            .style("display", "flex")
+            .style("flex-direction", "column")
+            .style("justify-content", "center")
+            .style("align-items", "center");
     }
 }
-Aggregator.aggregatorValueClass = 'aggregator-value';
-Aggregator.aggregatorTitleClass = 'aggregator-name';
-Aggregator.aggregatorObjectClass = 'aggregator-object';
+Aggregator.aggregatorValueClass = "aggregator-value";
+Aggregator.aggregatorTitleClass = "aggregator-name";
+Aggregator.aggregatorObjectClass = "aggregator-object";

package/lib/engine/features/axis/axis.d.ts

@@ -1,7 +1,7 @@
 import { AxisModelOptions, IAxisModel, IScaleModel } from "../../../model/model";
 import { Block } from "../../block/block";
 import { ScalesWithSecondary } from "../scale/scale";
-import { Size } from '../../../config/config';
+import { Size } from "../../../config/config";
 export declare class Axis {
     static axesClass: string;
     static render(block: Block, scales: ScalesWithSecondary, scaleModel: IScaleModel, axisModel: IAxisModel, blockSize: Size): void;

package/lib/engine/features/axis/axis.js

@@ -1,11 +1,11 @@
 import { Scale } from "../scale/scale";
-import { NamesHelper } from '../../helpers/namesHelper';
-import { AxisHelper } from './axisHelper';
-import { AxisLabelHelper } from './axisLabelDomHelper';
-import { AxisDomHelper } from './axisDomHelper';
-import { select } from 'd3-selection';
-import { AxisLabelsEventManager } from './axisLabelsEventManager';
-import { AXIS_VERTICAL_LABEL_PADDING } from '../../../model/margin/twoDim/twoDimMarginModel';
+import { NamesHelper } from "../../helpers/namesHelper";
+import { AxisHelper } from "./axisHelper";
+import { AxisLabelHelper } from "./axisLabelDomHelper";
+import { AxisDomHelper } from "./axisDomHelper";
+import { select } from "d3-selection";
+import { AxisLabelsEventManager } from "./axisLabelsEventManager";
+import { AXIS_VERTICAL_LABEL_PADDING } from "../../../model/margin/twoDim/twoDimMarginModel";
 const MINIMAL_STEP_SIZE_FOR_WRAPPING = 38;
 export class Axis {
     static render(block, scales, scaleModel, axisModel, blockSize) {
@@ -31,35 +31,39 @@ export class Axis {
         axisElement.raise();
     }
     static findAxis(block, axisCssClass) {
-        return block.getSvg()
-            .select(`g.${axisCssClass}`);
+        return block.getSvg().select(`g.${axisCssClass}`);
     }
     static renderAxis(block, scale, scaleOptions, axisOptions, blockSize) {
         const axisGenerator = AxisHelper.getBaseAxisGenerator(axisOptions, scale);
-        if (axisOptions.type === 'value' && (scaleOptions.type === 'linear' || scaleOptions.type === 'datetime'))
-            AxisHelper.setValueAxisLabelsSettings(axisGenerator, scale.range(), scaleOptions, axisOptions.labels);
+        if (axisOptions.type === "value" && scaleOptions.type === "linear")
+            AxisHelper.setValueAxisLabelsSettings(axisGenerator, scaleOptions, axisOptions.labels);
         else
             axisGenerator.tickFormat(axisOptions.labels.showTick);
-        const axisElement = block.getSvg()
-            .append('g')
-            .attr('class', `${this.axesClass} ${axisOptions.cssClass} data-label`);
+        const axisElement = block
+            .getSvg()
+            .append("g")
+            .attr("class", `${this.axesClass} ${axisOptions.cssClass} data-label`);
         AxisDomHelper.updateAxisElement(axisGenerator, axisElement, axisOptions.translate);
         if (!axisOptions.line.visible)
-            axisElement.select('.domain').style('display', 'none');
+            axisElement.select(".domain").style("display", "none");
         if (!axisOptions.labels.visible) {
             AxisLabelHelper.hideLabels(axisElement);
             return;
         }
-        if (axisOptions.type === 'key') {
-            if (axisOptions.labels.position === 'rotated' && (axisOptions.orient === 'top' || axisOptions.orient === 'bottom'))
+        if (axisOptions.type === "key") {
+            if (axisOptions.labels.position === "rotated" &&
+                (axisOptions.orient === "top" || axisOptions.orient === "bottom"))
                 AxisLabelHelper.rotateLabels(axisElement, axisOptions.orient);
-            if ((axisOptions.orient === 'left' || axisOptions.orient === 'right') && Scale.getScaleStep(scale) >= MINIMAL_STEP_SIZE_FOR_WRAPPING)
-                axisElement.selectAll('.tick text').call(AxisLabelHelper.wrapHandler, axisOptions.labels.maxSize);
+            if ((axisOptions.orient === "left" || axisOptions.orient === "right") &&
+                Scale.getScaleStep(scale) >= MINIMAL_STEP_SIZE_FOR_WRAPPING)
+                axisElement
+                    .selectAll(".tick text")
+                    .call(AxisLabelHelper.wrapHandler, axisOptions.labels.maxSize);
             else
                 AxisLabelHelper.cropLabels(block, scale, scaleOptions, axisOptions, blockSize);
             AxisLabelHelper.alignLabelsInKeyAxis(axisOptions, axisElement);
             AxisLabelsEventManager.setHoverEvents(block, axisElement);
-            block.filterEventManager.eventEmitter.subscribe('change', (selectedKeys) => {
+            block.filterEventManager.eventEmitter.subscribe("change", (selectedKeys) => {
                 this.handleLabelsHighlight(axisElement, selectedKeys);
             });
         }
@@ -71,38 +75,36 @@ export class Axis {
     }
     static updateValueAxis(block, scaleValue, scaleOptions, axisOptions, blockSize) {
         const axisGenerator = AxisHelper.getBaseAxisGenerator(axisOptions, scaleValue);
-        AxisHelper.setValueAxisLabelsSettings(axisGenerator, scaleValue.range(), scaleOptions, axisOptions.labels);
+        AxisHelper.setValueAxisLabelsSettings(axisGenerator, scaleOptions, axisOptions.labels);
         const axisElement = block.getSvg().select(`g.${axisOptions.cssClass}`);
-        AxisDomHelper.updateAxisElement(axisGenerator, axisElement, axisOptions.translate, block.transitionManager.durations.chartUpdate)
-            .then(() => {
+        AxisDomHelper.updateAxisElement(axisGenerator, axisElement, axisOptions.translate, block.transitionManager.durations.chartUpdate).then(() => {
             if (axisOptions.labels.defaultTooltip)
                 AxisLabelHelper.setTitles(axisElement, axisOptions);
-            if (axisOptions.orient === 'bottom' || axisOptions.orient === 'top') {
+            if (axisOptions.orient === "bottom" || axisOptions.orient === "top") {
                 AxisLabelHelper.cropLabels(block, scaleValue, scaleOptions, axisOptions, blockSize);
             }
         });
     }
     static updateKeyAxis(block, scaleKey, scaleOptions, axisOptions, blockSize, domainNotUpdated) {
         const axisGenerator = AxisHelper.getBaseAxisGenerator(axisOptions, scaleKey);
-        if (axisOptions.labels.position === 'rotated') { // Задание координат для перевернутых лейблов (если до этого они не были перевернуты)
-            if (axisOptions.orient === 'bottom')
+        if (axisOptions.labels.position === "rotated") {
+            // Задание координат для перевернутых лейблов (если до этого они не были перевернуты)
+            if (axisOptions.orient === "bottom")
                 axisGenerator.tickPadding(-4);
-            else if (axisOptions.orient === 'top')
+            else if (axisOptions.orient === "top")
                 axisGenerator.tickPadding(-6);
         }
         axisGenerator.tickFormat(axisOptions.labels.showTick);
-        const axisElement = block.getSvg()
-            .select(`g.${axisOptions.cssClass}`);
+        const axisElement = block.getSvg().select(`g.${axisOptions.cssClass}`);
         AxisLabelsEventManager.removeEvents(axisElement);
-        if (axisOptions.orient === 'left' || axisOptions.orient === 'right') {
-            axisElement.selectAll('.tick text').attr('y', null);
-            if (axisOptions.orient === 'left')
+        if (axisOptions.orient === "left" || axisOptions.orient === "right") {
+            axisElement.selectAll(".tick text").attr("y", null);
+            if (axisOptions.orient === "left")
                 axisGenerator.tickPadding(axisOptions.labels.maxSize + AXIS_VERTICAL_LABEL_PADDING);
         }
         // Если ключи оси не меняются, то обновление происходит без анимации
-        AxisDomHelper.updateAxisElement(axisGenerator, axisElement, axisOptions.translate, domainNotUpdated ? 0 : block.transitionManager.durations.chartUpdate)
-            .then(() => {
-            if (axisOptions.orient === 'bottom' || axisOptions.orient === 'top') {
+        AxisDomHelper.updateAxisElement(axisGenerator, axisElement, axisOptions.translate, domainNotUpdated ? 0 : block.transitionManager.durations.chartUpdate).then(() => {
+            if (axisOptions.orient === "bottom" || axisOptions.orient === "top") {
                 AxisLabelHelper.cropLabels(block, scaleKey, scaleOptions, axisOptions, blockSize);
             }
             AxisLabelsEventManager.setHoverEvents(block, axisElement);
@@ -117,26 +119,29 @@ export class Axis {
             if (frame < 10)
                 requestAnimationFrame(labelHandler);
             if (frame === 2) {
-                axisElement.selectAll('.tick').each(function (d) {
-                    if (scaleKey.domain().findIndex(key => key === d) === -1) {
-                        select(this).style('opacity', 0);
+                axisElement.selectAll(".tick").each(function (d) {
+                    if (scaleKey.domain().findIndex((key) => key === d) === -1) {
+                        select(this).style("opacity", 0);
                     }
                     else {
-                        select(this).style('opacity', 1);
+                        select(this).style("opacity", 1);
                     }
                 });
             }
-            if (axisOptions.orient === 'left' || axisOptions.orient === 'right') {
+            if (axisOptions.orient === "left" || axisOptions.orient === "right") {
                 if (Scale.getScaleStep(scaleKey) >= MINIMAL_STEP_SIZE_FOR_WRAPPING)
-                    axisElement.selectAll('.tick text').call(AxisLabelHelper.wrapHandler, axisOptions.labels.maxSize);
+                    axisElement
+                        .selectAll(".tick text")
+                        .call(AxisLabelHelper.wrapHandler, axisOptions.labels.maxSize);
                 else
                     AxisLabelHelper.cropLabels(block, scaleKey, scaleOptions, axisOptions, blockSize);
                 AxisLabelHelper.alignLabelsInKeyAxis(axisOptions, axisElement);
             }
-            if (axisOptions.orient === 'bottom' || axisOptions.orient === 'top') {
-                if (axisOptions.labels.position === 'rotated')
+            if (axisOptions.orient === "bottom" || axisOptions.orient === "top") {
+                if (axisOptions.labels.position === "rotated")
                     AxisLabelHelper.rotateLabels(axisElement, axisOptions.orient);
-                if (axisOptions.labels.position === 'straight') // Обратное выравнивание лейблов, если они были перевернуты, но теперь могут отображаться прямо
+                if (axisOptions.labels.position === "straight")
+                    // Обратное выравнивание лейблов, если они были перевернуты, но теперь могут отображаться прямо
                     AxisDomHelper.rotateElementsBack(axisElement);
                 AxisLabelHelper.cropLabels(block, scaleKey, scaleOptions, axisOptions, blockSize);
             }
@@ -144,14 +149,14 @@ export class Axis {
         requestAnimationFrame(labelHandler);
     }
     static handleLabelsHighlight(axisElement, selectedKeys) {
-        const labels = axisElement.selectAll('.tick text');
+        const labels = axisElement.selectAll(".tick text");
         if (selectedKeys.length === 0)
-            labels.classed('mdt-charts-opacity-inactive', false);
+            labels.classed("mdt-charts-opacity-inactive", false);
         else
             labels.each(function (data) {
                 const isActive = selectedKeys.includes(data);
-                select(this).classed('mdt-charts-opacity-inactive', !isActive);
+                select(this).classed("mdt-charts-opacity-inactive", !isActive);
             });
     }
 }
-Axis.axesClass = NamesHelper.getClassName('axis');
+Axis.axesClass = NamesHelper.getClassName("axis");

package/lib/engine/features/axis/axisDomHelper.d.ts

@@ -1,6 +1,6 @@
-import { Selection, BaseType } from 'd3-selection';
-import { Axis as IAxis } from 'd3-axis';
-import { TranslateModel } from '../../../model/model';
+import { Selection, BaseType } from "d3-selection";
+import { Axis as IAxis } from "d3-axis";
+import { TranslateModel } from "../../../model/model";
 export declare class AxisDomHelper {
     static updateAxisElement(axisGenerator: IAxis<any>, axisElement: Selection<SVGGElement, any, BaseType, any>, translate: TranslateModel, transitionDuration?: number): Promise<string>;
     static rotateElementsBack(axisElement: Selection<SVGGElement, unknown, HTMLElement, any>): void;

package/lib/engine/features/axis/axisDomHelper.js

@@ -1,24 +1,22 @@
 export class AxisDomHelper {
     static updateAxisElement(axisGenerator, axisElement, translate, transitionDuration = 0) {
-        return new Promise(resolve => {
+        return new Promise((resolve) => {
             let axisHandler = axisElement;
             if (transitionDuration > 0) {
                 axisHandler = axisHandler
                     .interrupt()
                     .transition()
                     .duration(transitionDuration)
-                    .on('end', () => resolve('updated'));
+                    .on("end", () => resolve("updated"));
             }
-            axisHandler.attr('transform', `translate(${translate.translateX}, ${translate.translateY})`)
+            axisHandler
+                .attr("transform", `translate(${translate.translateX}, ${translate.translateY})`)
                 .call(axisGenerator.bind(this));
             if (transitionDuration <= 0)
-                resolve('updated');
+                resolve("updated");
         });
     }
     static rotateElementsBack(axisElement) {
-        axisElement.selectAll('.tick text')
-            .attr('transform', null)
-            .attr('text-anchor', 'middle')
-            .attr('x', null);
+        axisElement.selectAll(".tick text").attr("transform", null).attr("text-anchor", "middle").attr("x", null);
     }
 }

package/lib/engine/features/axis/axisHelper.d.ts

@@ -1,8 +1,8 @@
-import { AxisScale, Axis as IAxis } from 'd3-axis';
+import { AxisScale, Axis as IAxis } from "d3-axis";
 import { AxisLabelModel, AxisModelOptions, Orient, ScaleValueModel } from "../../../model/model";
 export declare class AxisHelper {
     static getAxisByOrient(orient: Orient, scale: AxisScale<any>): IAxis<any>;
-    static setValueAxisLabelsSettings(axisGenerator: IAxis<any>, range: number[], scaleOptions: ScaleValueModel, labelsOptions: AxisLabelModel): void;
+    static setValueAxisLabelsSettings(axisGenerator: IAxis<any>, scaleOptions: ScaleValueModel, labelsOptions: AxisLabelModel): void;
     static getBaseAxisGenerator(axisOptions: AxisModelOptions, scale: AxisScale<any>): IAxis<any>;
     private static removeTicks;
     private static setNumTickFormat;

package/lib/engine/features/axis/axisHelper.js

@@ -1,30 +1,23 @@
-import { axisTop, axisBottom, axisLeft, axisRight } from 'd3-axis';
-import { format } from 'd3-format';
-import { AxisLabelHelper } from './axisLabelDomHelper';
-import { max, min } from 'd3-array';
-import { AxisModel } from "../../../model/featuresModel/axisModel";
+import { axisTop, axisBottom, axisLeft, axisRight } from "d3-axis";
+import { format } from "d3-format";
+import { AxisLabelHelper } from "./axisLabelDomHelper";
 export class AxisHelper {
     static getAxisByOrient(orient, scale) {
-        if (orient === 'top')
+        if (orient === "top")
             return axisTop(scale);
-        if (orient === 'bottom')
+        if (orient === "bottom")
             return axisBottom(scale);
-        if (orient === 'left')
+        if (orient === "left")
             return axisLeft(scale);
-        if (orient === 'right')
+        if (orient === "right")
             return axisRight(scale);
     }
-    static setValueAxisLabelsSettings(axisGenerator, range, scaleOptions, labelsOptions) {
-        const axisLength = range[1] - range[0];
-        const minimalStepSize = labelsOptions.linearTickStep;
-        if (Math.floor(axisLength / minimalStepSize) > 2) {
-            axisGenerator.ticks(Math.floor(axisLength / minimalStepSize));
-        }
-        else {
-            const roundedMaxValue = AxisModel.getRoundValue(max(scaleOptions.domain));
-            axisGenerator.tickValues([min(scaleOptions.domain), roundedMaxValue]);
-        }
-        if (scaleOptions.type === 'linear') {
+    static setValueAxisLabelsSettings(axisGenerator, scaleOptions, labelsOptions) {
+        if (labelsOptions.tickAmountSettings.policy.type === "amount")
+            axisGenerator.ticks(labelsOptions.tickAmountSettings.policy.amount);
+        if (labelsOptions.tickAmountSettings.policy.type === "constant")
+            axisGenerator.tickValues(labelsOptions.tickAmountSettings.policy.values);
+        if (scaleOptions.type === "linear") {
             this.setNumTickFormat(axisGenerator, scaleOptions.formatter);
         }
     }
@@ -39,7 +32,7 @@ export class AxisHelper {
         axis.tickSize(0);
     }
     static setNumTickFormat(axis, formatter) {
-        const defaultFormatter = format('~s');
+        const defaultFormatter = format("~s");
         axis.tickFormat(formatter !== null && formatter !== void 0 ? formatter : defaultFormatter);
     }
 }

package/lib/engine/features/axis/axisLabelDomHelper.d.ts

@@ -1,8 +1,8 @@
-import { Selection, BaseType } from 'd3-selection';
-import { AxisScale, Axis as IAxis } from 'd3-axis';
+import { Selection, BaseType } from "d3-selection";
+import { AxisScale, Axis as IAxis } from "d3-axis";
 import { AxisModelOptions, Orient, ScaleKeyModel, ScaleValueModel } from "../../../model/model";
 import { Block } from "../../block/block";
-import { Size } from '../../../config/config';
+import { Size } from "../../../config/config";
 export declare class AxisLabelHelper {
     static setTitles(axisElement: Selection<SVGGElement, unknown, BaseType, any>, axisOptions: AxisModelOptions): void;
     static setAxisLabelPaddingByOrient(axis: IAxis<any>, axisOptions: AxisModelOptions): void;