scichart 3.2.481 → 3.2.509

package/Charting/ChartModifiers/CursorModifier.js

@@ -222,18 +222,14 @@ var CursorModifier = /** @class */ (function (_super) {
      * @inheritDoc
      */
     CursorModifier.prototype.onDetach = function () {
-        var _a;
         _super.prototype.onDetach.call(this);
         if (this.xLineAnnotation) {
-            (_a = this.xLineAnnotation) === null || _a === void 0 ? void 0 : _a.delete();
-            this.parentSurface.modifierAnnotations.remove(this.xLineAnnotation);
+            this.parentSurface.modifierAnnotations.remove(this.xLineAnnotation, true);
         }
         if (this.yLineAnnotation) {
-            this.yLineAnnotation.delete();
-            this.parentSurface.modifierAnnotations.remove(this.yLineAnnotation);
+            this.parentSurface.modifierAnnotations.remove(this.yLineAnnotation, true);
         }
-        this.tooltipAnnotation.delete();
-        this.parentSurface.modifierAnnotations.remove(this.tooltipAnnotation);
+        this.parentSurface.modifierAnnotations.remove(this.tooltipAnnotation, true);
     };
     /**
      * @inheritDoc

package/Charting/ChartModifiers/RolloverModifier.js

@@ -250,8 +250,7 @@ var RolloverModifier = /** @class */ (function (_super) {
     RolloverModifier.prototype.onDetach = function () {
         var _this = this;
         _super.prototype.onDetach.call(this);
-        this.rolloverLineAnnotation.delete();
-        this.parentSurface.modifierAnnotations.remove(this.rolloverLineAnnotation);
+        this.parentSurface.modifierAnnotations.remove(this.rolloverLineAnnotation, true);
         this.parentSurface.modifierAnnotations.remove(this.legendAnnotation);
         this.getIncludedRenderableSeries().forEach(function (rs) { return _this.removeSeriesAnnotationsFromParentSurface(rs); });
     };

package/Charting/ChartModifiers/VerticalSliceModifier.js

@@ -200,6 +200,12 @@ var VerticalSliceModifier = /** @class */ (function (_super) {
         this.calculateXPosition();
         this.updateLine();
         this.updateSeriesAnnotations();
+        Array.from(this.rmrsProps.values()).forEach(function (rmrsp) {
+            if (!rmrsp.renderableSeries.isVisible || !rmrsp.showRollover) {
+                rmrsp.tooltip.isHidden = true;
+                rmrsp.marker.isHidden = true;
+            }
+        });
         if (this.tooltipLegendTemplate) {
             this.legendAnnotation.seriesInfos = this.getSeriesInfos();
         }

package/Charting/Drawing/WebGlRenderContext2D.d.ts

@@ -38,7 +38,7 @@ export declare enum ELineDrawMode {
  */
 export declare class WebGlRenderContext2D extends DeletableEntity implements IRenderContext2D {
     /**
-     * Should store Stores references to all cached WebGlResources {@link ICacheable}
+     * Should store references to all cached WebGlResources {@link ICacheable}
      * Is used to invalidate the resources when the WebGL context is lost.
      */
     static readonly webGlResourcesRefs: Set<ICacheable>;

package/Charting/Drawing/WebGlRenderContext2D.js

@@ -358,7 +358,7 @@ var WebGlRenderContext2D = /** @class */ (function (_super) {
         }
     };
     /**
-     * Should store Stores references to all cached WebGlResources {@link ICacheable}
+     * Should store references to all cached WebGlResources {@link ICacheable}
      * Is used to invalidate the resources when the WebGL context is lost.
      */
     WebGlRenderContext2D.webGlResourcesRefs = new Set();

package/Charting/LayoutManager/SynchronizedLayoutManager.js

@@ -46,6 +46,12 @@ var SynchronizedLayoutManager = /** @class */ (function (_super) {
         _super.prototype.measureLeftOuterAxes.call(this);
         this.verticalGroup.onLeftSizeChanged(this.id, this.chartLayoutState.leftOuterAreaSize);
         var newSize = Math.max(this.chartLayoutState.leftOuterAreaSize, this.verticalGroup.groupLeftSize);
+        // Sync axis widths. Expand the outer one only.
+        if (this.axesGroupedByLayoutStrategy.leftOuterAxes.length > 0) {
+            var axis = this.axesGroupedByLayoutStrategy.leftOuterAxes[this.axesGroupedByLayoutStrategy.leftOuterAxes.length - 1];
+            var otherSize = this.chartLayoutState.leftOuterAreaSize - axis.axisLayoutState.axisSize;
+            axis.axisLayoutState.axisSize = newSize - otherSize;
+        }
         this.chartLayoutState.leftOuterAreaSize = newSize;
         this.lastLeftOuterAreaSize = newSize;
     };
@@ -53,6 +59,12 @@ var SynchronizedLayoutManager = /** @class */ (function (_super) {
         _super.prototype.measureRightOuterAxes.call(this);
         this.verticalGroup.onRightSizeChanged(this.id, this.chartLayoutState.rightOuterAreaSize);
         var newSize = Math.max(this.chartLayoutState.rightOuterAreaSize, this.verticalGroup.groupRightSize);
+        // Sync axis widths. Expand the outer one only.
+        if (this.axesGroupedByLayoutStrategy.rightOuterAxes.length > 0) {
+            var axis = this.axesGroupedByLayoutStrategy.rightOuterAxes[this.axesGroupedByLayoutStrategy.rightOuterAxes.length - 1];
+            var otherSize = this.chartLayoutState.rightOuterAreaSize - axis.axisLayoutState.axisSize;
+            axis.axisLayoutState.axisSize = newSize - otherSize;
+        }
         this.chartLayoutState.rightOuterAreaSize = newSize;
         this.lastRightOuterAreaSize = newSize;
     };

package/Charting/Numerics/TickCoordinateProviders/DefaultTickCoordinatesProvider.d.ts

@@ -1,7 +1,12 @@
 import { TickCoordinatesProvider } from "./TickCoordinatesProvider";
 export declare class DefaultTickCoordinatesProvider extends TickCoordinatesProvider {
+    /**
+     * @inheritDoc
+     */
     getTickCoordinates(majorTicks: number[], minorTicks: number[]): {
         majorTickCoords: number[];
         minorTickCoords: number[];
+        majorTickOverrides: number[];
+        minorTickOverRides: number[];
     };
 }

package/Charting/Numerics/TickCoordinateProviders/DefaultTickCoordinatesProvider.js

@@ -22,12 +22,22 @@ var DefaultTickCoordinatesProvider = /** @class */ (function (_super) {
     function DefaultTickCoordinatesProvider() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * @inheritDoc
+     */
     DefaultTickCoordinatesProvider.prototype.getTickCoordinates = function (majorTicks, minorTicks) {
+        if (majorTicks === undefined)
+            return {
+                majorTickCoords: undefined,
+                minorTickCoords: undefined,
+                majorTickOverrides: undefined,
+                minorTickOverRides: undefined
+            };
         var coordinateCalculator = this.parentAxis.getCurrentCoordinateCalculator();
         // Rounding and +0.5 required to have lines on exact pixel boundaries.
         var majorTickCoords = majorTicks.map(function (t) { return Math.round(coordinateCalculator.getCoordinate(t)) + 0.5; });
         var minorTickCoords = minorTicks.map(function (t) { return Math.round(coordinateCalculator.getCoordinate(t)) + 0.5; });
-        return { majorTickCoords: majorTickCoords, minorTickCoords: minorTickCoords };
+        return { majorTickCoords: majorTickCoords, minorTickCoords: minorTickCoords, majorTickOverrides: majorTicks, minorTickOverRides: minorTicks };
     };
     return DefaultTickCoordinatesProvider;
 }(TickCoordinatesProvider_1.TickCoordinatesProvider));

package/Charting/Numerics/TickCoordinateProviders/StaticTickCoordinatesProvider.d.ts

@@ -0,0 +1,19 @@
+import { DefaultTickCoordinatesProvider } from "./DefaultTickCoordinatesProvider";
+export declare class StaticTickCoordinatesProvider extends DefaultTickCoordinatesProvider {
+    private tickCoords;
+    private prevRange;
+    private prevSize;
+    /**
+     * @inheritDoc
+     */
+    getTickCoordinates(majorTicks: number[], minorTicks: number[]): {
+        majorTickCoords: number[];
+        minorTickCoords: number[];
+        majorTickOverrides: number[];
+        minorTickOverRides: number[];
+    };
+    /** Update the static tick positions to correspond with the current calculated tick values */
+    forceRecalculateCoords(): void;
+    private OverrideTickValues;
+    private OverrideTickCoordinates;
+}

package/Charting/Numerics/TickCoordinateProviders/StaticTickCoordinatesProvider.js

@@ -0,0 +1,86 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticTickCoordinatesProvider = void 0;
+var DefaultTickCoordinatesProvider_1 = require("./DefaultTickCoordinatesProvider");
+var StaticTickCoordinatesProvider = /** @class */ (function (_super) {
+    __extends(StaticTickCoordinatesProvider, _super);
+    function StaticTickCoordinatesProvider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    StaticTickCoordinatesProvider.prototype.getTickCoordinates = function (majorTicks, minorTicks) {
+        var visibleRangeChanged = !this.parentAxis.visibleRange.equals(this.prevRange);
+        var axisSizeChanged = this.parentAxis.getAxisSize() !== this.prevSize;
+        var coordinateCalculator = this.parentAxis.getCurrentCoordinateCalculator();
+        var majorTickOverrides;
+        var minorTickOverRides;
+        if (this.tickCoords === undefined || axisSizeChanged) {
+            if (majorTicks === undefined) {
+                return {
+                    majorTickCoords: undefined,
+                    minorTickCoords: undefined,
+                    majorTickOverrides: undefined,
+                    minorTickOverRides: undefined
+                };
+            }
+            var majorTickCoords = majorTicks.map(function (t) { return coordinateCalculator.getCoordinate(t); });
+            var minorTickCoords = minorTicks.map(function (t) { return coordinateCalculator.getCoordinate(t); });
+            this.tickCoords = { majorTickCoords: majorTickCoords, minorTickCoords: minorTickCoords, majorTicks: majorTicks, minorTicks: minorTicks, majorTickLabels: undefined };
+        }
+        else if (visibleRangeChanged) {
+            this.OverrideTickValues(this.tickCoords);
+            (majorTickOverrides = this.tickCoords.majorTicks), (minorTickOverRides = this.tickCoords.minorTicks);
+        }
+        else {
+            this.OverrideTickCoordinates(this.tickCoords);
+        }
+        this.prevRange = this.parentAxis.visibleRange;
+        this.prevSize = this.parentAxis.getAxisSize();
+        //console.log(this.tickCoords.majorTickCoords, this.tickCoords.majorTicks);
+        return {
+            majorTickCoords: this.tickCoords.majorTickCoords.map(function (t) { return Math.round(t + 0.5); }),
+            minorTickCoords: this.tickCoords.minorTickCoords.map(function (t) { return Math.round(t + 0.5); }),
+            majorTickOverrides: majorTickOverrides,
+            minorTickOverRides: minorTickOverRides
+        };
+    };
+    /** Update the static tick positions to correspond with the current calculated tick values */
+    StaticTickCoordinatesProvider.prototype.forceRecalculateCoords = function () {
+        this.tickCoords = undefined;
+    };
+    StaticTickCoordinatesProvider.prototype.OverrideTickValues = function (tickCoords) {
+        var coordinateCalculator = this.parentAxis.getCurrentCoordinateCalculator();
+        if (coordinateCalculator != null) {
+            tickCoords.minorTickCoords.forEach(function (t, i) { return (tickCoords.minorTicks[i] = coordinateCalculator.getDataValue(t)); });
+            tickCoords.majorTickCoords.forEach(function (t, i) { return (tickCoords.majorTicks[i] = coordinateCalculator.getDataValue(t)); });
+        }
+    };
+    StaticTickCoordinatesProvider.prototype.OverrideTickCoordinates = function (tickCoords) {
+        var coordinateCalculator = this.parentAxis.getCurrentCoordinateCalculator();
+        if (coordinateCalculator != null) {
+            if (coordinateCalculator != null) {
+                tickCoords.minorTicks.forEach(function (t, i) { return (tickCoords.minorTickCoords[i] = coordinateCalculator.getCoordinate(t)); });
+                tickCoords.majorTicks.forEach(function (t, i) { return (tickCoords.majorTickCoords[i] = coordinateCalculator.getCoordinate(t)); });
+            }
+        }
+    };
+    return StaticTickCoordinatesProvider;
+}(DefaultTickCoordinatesProvider_1.DefaultTickCoordinatesProvider));
+exports.StaticTickCoordinatesProvider = StaticTickCoordinatesProvider;

package/Charting/Numerics/TickCoordinateProviders/TickCoordinatesProvider.d.ts

@@ -25,5 +25,7 @@ export declare abstract class TickCoordinatesProvider {
     abstract getTickCoordinates(majorTicks: number[], minorTicks: number[]): {
         majorTickCoords: number[];
         minorTickCoords: number[];
+        majorTickOverrides: number[];
+        minorTickOverRides: number[];
     };
 }

package/Charting/Numerics/TickProviders/LogarithmicTickProvider.d.ts

@@ -25,6 +25,7 @@ export declare enum ELogarithmicMajorTickMode {
  */
 export declare class LogarithmicTickProvider extends TickProvider {
     logarithmicBase: number;
+    isHighPrecisionTicks: boolean;
     private wasmContext;
     private majorTickModeProperty;
     private minorTickModeProperty;

package/Charting/Numerics/TickProviders/LogarithmicTickProvider.js

@@ -48,6 +48,7 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
     function LogarithmicTickProvider(wasmContext) {
         var _this = _super.call(this) || this;
         _this.logarithmicBase = 10;
+        _this.isHighPrecisionTicks = true;
         _this.majorTickModeProperty = ELogarithmicMajorTickMode.EqualSpacing;
         _this.minorTickModeProperty = ELogarithmicMinorTickMode.Linear;
         _this.wasmContext = wasmContext;
@@ -121,11 +122,14 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
         }
         else {
             var results = [];
+            if (this.logarithmicBase === 0)
+                return results;
             var current = visibleRange.min;
             var min = visibleRange.min;
             var max = visibleRange.max;
             var numberUtil = this.wasmContext.NumberUtil;
-            if (!numberUtil.IsPowerOf(current, this.logarithmicBase, this.logarithmicBase)) {
+            if (!this.isHighPrecisionTicks &&
+                !numberUtil.IsPowerOf(current, this.logarithmicBase, this.logarithmicBase)) {
                 current = numberUtil.RoundDownPower(current, this.logarithmicBase, this.logarithmicBase);
             }
             var start = numberUtil.Log(current, this.logarithmicBase);
@@ -144,6 +148,7 @@ var LogarithmicTickProvider = /** @class */ (function (_super) {
                 exp = start + ++tickCount * majorDelta;
                 current = Math.pow(this.logarithmicBase, exp);
             }
+            //console.log(majorDelta, minorDelta, results);
             if (adj === -1) {
                 return results.reverse();
             }

package/Charting/Visuals/Annotations/CursorTooltipSvgAnnotation.d.ts

@@ -65,8 +65,7 @@ export declare class CursorTooltipSvgAnnotation extends SvgAnnotationBase {
      * @inheritDoc
      */
     update(xCalc: CoordinateCalculatorBase, yCalc: CoordinateCalculatorBase, xCoordSvgTrans: number, yCoordSvgTrans: number): void;
-    /** @inheritDoc */
-    delete(): void;
+    clear(): void;
     /**
      * @inheritDoc
      */

package/Charting/Visuals/Annotations/CursorTooltipSvgAnnotation.js

@@ -179,7 +179,7 @@ var CursorTooltipSvgAnnotation = /** @class */ (function (_super) {
         }
         this.previousMousePosition = this.cursorModifier.getMousePosition();
         if (this.svg) {
-            this.delete();
+            this.clear();
         }
         this.create(xCalc, yCalc, xCoordSvgTrans, yCoordSvgTrans);
         if (this.placementDivId) {
@@ -190,8 +190,7 @@ var CursorTooltipSvgAnnotation = /** @class */ (function (_super) {
             this.updateLegendTooltip();
         }
     };
-    /** @inheritDoc */
-    CursorTooltipSvgAnnotation.prototype.delete = function () {
+    CursorTooltipSvgAnnotation.prototype.clear = function () {
         if (!this.parentSurface || this.parentSurface.isDeleted || !this.svg)
             return;
         if (this.placementDivId) {

package/Charting/Visuals/Annotations/RolloverMarkerSvgAnnotation.js

@@ -46,7 +46,7 @@ var RolloverMarkerSvgAnnotation = /** @class */ (function (_super) {
     /** @inheritDoc */
     RolloverMarkerSvgAnnotation.prototype.create = function (xCalc, yCalc, xCoordSvgTrans, yCoordSvgTrans) {
         if (this.svg) {
-            this.delete();
+            this.clear();
         }
         var _a = this.tooltipProps, tooltipColor = _a.tooltipColor, markerColor = _a.markerColor;
         var svgString = tooltipSvgTemplate(markerColor !== null && markerColor !== void 0 ? markerColor : tooltipColor);

package/Charting/Visuals/Annotations/RolloverTooltipSvgAnnotation.d.ts

@@ -38,13 +38,12 @@ export declare class RolloverTooltipSvgAnnotation extends SvgAnnotationBase {
      */
     set seriesInfo(value: SeriesInfo);
     /** @inheritDoc */
-    delete(): void;
-    /** @inheritDoc */
     update(xCalc: CoordinateCalculatorBase, yCalc: CoordinateCalculatorBase, xCoordSvgTrans: number, yCoordSvgTrans: number): void;
     /**
      * Updates size of the tooltip
      */
     updateSize(width: number, height: number): void;
+    protected clear(): void;
     /** @inheritDoc */
     protected create(xCalc: CoordinateCalculatorBase, yCalc: CoordinateCalculatorBase, xCoordSvgTrans: number, yCoordSvgTrans: number): void;
     private generateSvgString;

package/Charting/Visuals/Annotations/RolloverTooltipSvgAnnotation.js

@@ -71,22 +71,6 @@ var RolloverTooltipSvgAnnotation = /** @class */ (function (_super) {
         configurable: true
     });
     /** @inheritDoc */
-    RolloverTooltipSvgAnnotation.prototype.delete = function () {
-        var _a, _b, _c, _d;
-        if (!this.parentSurface || this.parentSurface.isDeleted)
-            return;
-        if (this.svg) {
-            if (this.placementDivId) {
-                (_b = (_a = this.svg) === null || _a === void 0 ? void 0 : _a.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(this.svg);
-                return;
-            }
-            (_c = this.svgRoot) === null || _c === void 0 ? void 0 : _c.removeChild(this.svg);
-        }
-        if (this.svgLegend) {
-            (_d = this.svgLegend.parentNode) === null || _d === void 0 ? void 0 : _d.removeChild(this.svgLegend);
-        }
-    };
-    /** @inheritDoc */
     RolloverTooltipSvgAnnotation.prototype.update = function (xCalc, yCalc, xCoordSvgTrans, yCoordSvgTrans) {
         var currentMousePosition = this.tooltipProps.rolloverModifier.getMousePosition();
         if (this.previousMousePosition === currentMousePosition && currentMousePosition !== MousePosition_1.EMousePosition.SeriesArea) {
@@ -94,7 +78,7 @@ var RolloverTooltipSvgAnnotation = /** @class */ (function (_super) {
         }
         this.previousMousePosition = this.tooltipProps.rolloverModifier.getMousePosition();
         if (this.svg) {
-            this.delete();
+            this.clear();
         }
         if (this.placementDivId) {
             this.updateExternalLegendTooltip();
@@ -111,6 +95,21 @@ var RolloverTooltipSvgAnnotation = /** @class */ (function (_super) {
         this.width = width;
         this.height = height;
     };
+    RolloverTooltipSvgAnnotation.prototype.clear = function () {
+        var _a, _b, _c, _d;
+        if (!this.parentSurface || this.parentSurface.isDeleted)
+            return;
+        if (this.svg) {
+            if (this.placementDivId) {
+                (_b = (_a = this.svg) === null || _a === void 0 ? void 0 : _a.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(this.svg);
+                return;
+            }
+            (_c = this.svgRoot) === null || _c === void 0 ? void 0 : _c.removeChild(this.svg);
+        }
+        if (this.svgLegend) {
+            (_d = this.svgLegend.parentNode) === null || _d === void 0 ? void 0 : _d.removeChild(this.svgLegend);
+        }
+    };
     /** @inheritDoc */
     RolloverTooltipSvgAnnotation.prototype.create = function (xCalc, yCalc, xCoordSvgTrans, yCoordSvgTrans) {
         var svgString;

package/Charting/Visuals/Annotations/SvgAnnotationBase.d.ts

@@ -25,6 +25,7 @@ export interface ISvgAnnotationBaseOptions extends IAnnotationBaseOptions {
 export declare abstract class SvgAnnotationBase extends AnnotationBase {
     /** @inheritDoc */
     readonly isSvgAnnotation: boolean;
+    isDeleted: boolean;
     /**
      * The {@link SVGElement} which will be added to the chart
      */
@@ -97,6 +98,7 @@ export declare abstract class SvgAnnotationBase extends AnnotationBase {
         options: Required<Omit<IAnnotationBaseOptions, never>>;
     };
     get svg(): SVGElement;
+    protected clear(): void;
     protected checkIsClickedOnAnnotationInternal(x: number, y: number): boolean;
     protected updateAdornerInner(): void;
     /**

package/Charting/Visuals/Annotations/SvgAnnotationBase.js

@@ -39,6 +39,7 @@ var SvgAnnotationBase = /** @class */ (function (_super) {
         _this = _super.call(this, options) || this;
         /** @inheritDoc */
         _this.isSvgAnnotation = true;
+        _this.isDeleted = false;
         /**
          * The {@link SVGElement} which will be added to the chart
          */
@@ -253,10 +254,8 @@ var SvgAnnotationBase = /** @class */ (function (_super) {
     };
     /** @inheritDoc */
     SvgAnnotationBase.prototype.delete = function () {
-        if (!this.parentSurface || this.parentSurface.isDeleted || !this.svg)
-            return;
-        this.svgRoot.removeChild(this.svg);
-        this.setSvg(undefined);
+        this.clear();
+        this.isDeleted = true;
     };
     SvgAnnotationBase.prototype.toJSON = function () {
         var json = _super.prototype.toJSON.call(this);
@@ -276,6 +275,12 @@ var SvgAnnotationBase = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    SvgAnnotationBase.prototype.clear = function () {
+        if (!this.parentSurface || this.parentSurface.isDeleted || !this.svg)
+            return;
+        this.svgRoot.removeChild(this.svg);
+        this.setSvg(undefined);
+    };
     SvgAnnotationBase.prototype.checkIsClickedOnAnnotationInternal = function (x, y) {
         var _a = this.getAnnotationBorders(true), x1 = _a.x1, x2 = _a.x2, y1 = _a.y1, y2 = _a.y2;
         // For SVG annotations we need to use not scaled coordinates

package/Charting/Visuals/Axis/AxisBase2D.d.ts

@@ -161,6 +161,10 @@ export interface IAxisBase2dOptions extends IAxisCoreOptions {
      * You may want to set this false if you have stacked horizontal axes, or are using {@link offsetOverride}.
      */
     clipToXRange?: boolean;
+    /**
+     * Sets whether the gridlines and axis labels keep their initial position when the visible range changes.
+     */
+    isStaticAxis?: boolean;
 }
 /**
  * The base class for 2D Chart Axis within SciChart - High Performance {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}.
@@ -338,6 +342,14 @@ export declare abstract class AxisBase2D extends AxisCore implements IThemeable
      * You may want to set this false if you have stacked horizontal axes, or are using {@link offsetOverride}.
      */
     set clipToXRange(clipToXRange: boolean);
+    /**
+     * Gets whether the gridlines and axis labels keep their initial position when the visible range changes.
+     */
+    get isStaticAxis(): boolean;
+    /**
+     * Sets whether the gridlines and axis labels keep their initial position when the visible range changes.
+     */
+    set isStaticAxis(value: boolean);
     abstract type: EAxisType.CategoryAxis | EAxisType.LogarithmicAxis | EAxisType.NumericAxis | EAxisType.DateTimeNumericAxis;
     /**
      * Gets the parent {@link SciChartSurface} that this axis is attached to
@@ -386,6 +398,7 @@ export declare abstract class AxisBase2D extends AxisCore implements IThemeable
     private backgroundColorProperty;
     private dpiAdjustedLabelStyleCache;
     private clipToXRangeProperty;
+    private isStaticAxisProperty;
     /**
      * Creates an instance of the {@link AxisBase2D}
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and
@@ -523,7 +536,7 @@ export declare abstract class AxisBase2D extends AxisCore implements IThemeable
      */
     protected notifyPropertyChanged(propertyName: string): void;
     protected getMaxXRange(): NumberRange;
-    protected getAxisSize(): number;
+    getAxisSize(): number;
     private getMajorTickIndex;
     private getTicks;
     private getTicksWithCoords;