scichart 3.2.477 → 3.2.481

package/Charting/ChartModifiers/VerticalSliceModifier.js

@@ -0,0 +1,247 @@
+"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.VerticalSliceModifier = void 0;
+var RolloverModifier_1 = require("./RolloverModifier");
+var translate_1 = require("../../utils/translate");
+var Point_1 = require("../../Core/Point");
+var MousePosition_1 = require("../../types/MousePosition");
+var RolloverModifierRenderableSeriesProps_1 = require("../Visuals/RenderableSeries/RolloverModifier/RolloverModifierRenderableSeriesProps");
+var AnnotationBase_1 = require("../Visuals/Annotations/AnnotationBase");
+var SeriesType_1 = require("../../types/SeriesType");
+var constants_1 = require("./constants");
+var ChartModifierType_1 = require("../../types/ChartModifierType");
+var VerticalSliceModifier = /** @class */ (function (_super) {
+    __extends(VerticalSliceModifier, _super);
+    function VerticalSliceModifier(options) {
+        var _this = this;
+        var _a, _b, _c;
+        _this = _super.call(this, options) || this;
+        _this.xCoordinateModeProperty = AnnotationBase_1.ECoordinateMode.Pixel;
+        _this.isDraggableProperty = false;
+        _this.rmrsProps = new Map();
+        _this.rmrsProps1 = new Map();
+        // @ts-ignore
+        _this.type = ChartModifierType_1.EChart2DModifierType.VerticalSlice;
+        _this.x1Property = (_a = options.x1) !== null && _a !== void 0 ? _a : 0;
+        _this.mousePosition = MousePosition_1.EMousePosition.SeriesArea;
+        _this.xCoordinateModeProperty = (_b = options.xCoordinateMode) !== null && _b !== void 0 ? _b : _this.xCoordinateModeProperty;
+        _this.isDraggableProperty = (_c = options.isDraggable) !== null && _c !== void 0 ? _c : _this.isDraggableProperty;
+        _this.lineSelectionColorProperty = options.lineSelectionColor;
+        _this.rolloverLineAnnotation.isEditable = _this.isDraggableProperty;
+        _this.rolloverLineAnnotation.selectionBoxStroke = _this.lineSelectionColor;
+        return _this;
+    }
+    Object.defineProperty(VerticalSliceModifier.prototype, "x1", {
+        // properties - only update if changed
+        /** @inheritDoc */
+        get: function () {
+            return this.x1Property;
+        },
+        /** @inheritDoc */
+        set: function (value) {
+            if (value !== this.x1Property) {
+                this.x1Property = value;
+                this.notifyPropertyChanged(constants_1.PROPERTY.X1);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(VerticalSliceModifier.prototype, "xCoordinateMode", {
+        /** @inheritDoc */
+        get: function () {
+            return this.xCoordinateModeProperty;
+        },
+        /** @inheritDoc */
+        set: function (value) {
+            if (value !== this.xCoordinateModeProperty) {
+                this.xCoordinateModeProperty = value;
+                this.notifyPropertyChanged(constants_1.PROPERTY.X_COORDINATE_MODE);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(VerticalSliceModifier.prototype, "verticalLine", {
+        /** @inheritDoc */
+        get: function () {
+            // read only
+            return this.rolloverLineAnnotation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(VerticalSliceModifier.prototype, "isDraggable", {
+        /** @inheritDoc */
+        get: function () {
+            return this.isDraggableProperty;
+        },
+        /** @inheritDoc */
+        set: function (value) {
+            if (value != this.isDraggableProperty) {
+                this.isDraggableProperty = value;
+                this.notifyPropertyChanged(constants_1.PROPERTY.IS_DRAGGABLE);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(VerticalSliceModifier.prototype, "lineSelectionColor", {
+        /** @inheritDoc */
+        get: function () {
+            return this.lineSelectionColorProperty;
+        },
+        /** @inheritDoc */
+        set: function (value) {
+            if (value != this.lineSelectionColorProperty) {
+                this.lineSelectionColorProperty = value;
+                this.notifyPropertyChanged(constants_1.PROPERTY.LINE_SELECTION_COLOR);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VerticalSliceModifier.prototype.modifierMouseMove = function (args) {
+        //this.lastPoint = args.mousePoint;
+        if (this.rolloverLineAnnotation.isDraggingStarted) {
+            this.mousePoint = new Point_1.Point(args.mousePoint.x, args.mousePoint.y);
+            var x = this.isVerticalChart() ? args.mousePoint.y : args.mousePoint.x;
+            var xAxis = this.parentSurface.getXAxisById(this.xAxisId);
+            var coordCalc = xAxis.getCurrentCoordinateCalculator();
+            if (this.xCoordinateMode === AnnotationBase_1.ECoordinateMode.Pixel) {
+                this.x1 = (0, translate_1.translateToNotScaled)(x);
+            }
+            else if (this.xCoordinateMode === AnnotationBase_1.ECoordinateMode.Relative) {
+                this.x1 =
+                    (x - (this.isVerticalChart() ? xAxis.viewRect.top : xAxis.viewRect.left)) /
+                        coordCalc.viewportDimension;
+            }
+            else {
+                // DataValue
+                var xt = this.isVerticalChart()
+                    ? (0, translate_1.translateFromCanvasToSeriesViewRectY)(x, this.parentSurface.seriesViewRect)
+                    : (0, translate_1.translateFromCanvasToSeriesViewRectX)(x, this.parentSurface.seriesViewRect);
+                this.x1 = coordCalc.getDataValue(xt);
+            }
+            // Consider optional snap to dataPoint here
+            this.update();
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    VerticalSliceModifier.prototype.modifierMouseLeave = function (args) {
+        // do nothing, keep showing modifier
+    };
+    VerticalSliceModifier.prototype.toJSON = function () {
+        var json = _super.prototype.toJSON.call(this);
+        var options = {
+            x1: this.x1,
+            xCoordinateMode: this.xCoordinateMode,
+            isDraggable: this.isDraggable,
+            lineSelectionColor: this.lineSelectionColor
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    VerticalSliceModifier.prototype.getRolloverProps = function (rs) {
+        return this.rmrsProps.get(rs);
+    };
+    VerticalSliceModifier.prototype.getRolloverProps1 = function (rs) {
+        return this.rmrsProps.get(rs);
+    };
+    VerticalSliceModifier.prototype.removeSeriesAnnotationsFromParentSurface = function (rs) {
+        _super.prototype.removeSeriesAnnotationsFromParentSurface.call(this, rs); // will remove annotation
+        // clean up the dictionary
+        this.rmrsProps.get(rs).delete();
+        this.rmrsProps.delete(rs);
+        if (rs.type === SeriesType_1.ESeriesType.BandSeries) {
+            this.rmrsProps1.get(rs).delete();
+            this.rmrsProps1.delete(rs);
+        }
+    };
+    /**
+     * @param rs
+     */
+    VerticalSliceModifier.prototype.addSeriesAnnotationsToParentSurface = function (rs) {
+        var props = new RolloverModifierRenderableSeriesProps_1.RolloverModifierRenderableSeriesProps(rs, false); // true for second in band
+        RolloverModifierRenderableSeriesProps_1.RolloverModifierRenderableSeriesProps.copy(rs.rolloverModifierProps, props);
+        this.rmrsProps.set(rs, props);
+        if (rs.type === SeriesType_1.ESeriesType.BandSeries) {
+            var props1 = new RolloverModifierRenderableSeriesProps_1.RolloverModifierRenderableSeriesProps(rs, false); // true for second in band
+            RolloverModifierRenderableSeriesProps_1.RolloverModifierRenderableSeriesProps.copy(rs.rolloverModifierProps1, props1);
+            this.rmrsProps1.set(rs, props1);
+        }
+        _super.prototype.addSeriesAnnotationsToParentSurface.call(this, rs);
+    };
+    VerticalSliceModifier.prototype.createLine = function (options) {
+        var line = _super.prototype.createLine.call(this, options);
+        line.annotationsGripsRadius = 0;
+        // @ts-ignore
+        //line.updateAdornerInner = () => {};
+        return line;
+    };
+    VerticalSliceModifier.prototype.update = function () {
+        this.calculateXPosition();
+        this.updateLine();
+        this.updateSeriesAnnotations();
+        if (this.tooltipLegendTemplate) {
+            this.legendAnnotation.seriesInfos = this.getSeriesInfos();
+        }
+    };
+    /** @inheritDoc */
+    VerticalSliceModifier.prototype.notifyPropertyChanged = function (propertyName) {
+        _super.prototype.notifyPropertyChanged.call(this, propertyName);
+        // take action when property programmatically changed
+        switch (propertyName) {
+            case constants_1.PROPERTY.X1: {
+                this.calculateXPosition();
+                break;
+            }
+            case constants_1.PROPERTY.X_COORDINATE_MODE: {
+                this.calculateXPosition();
+                break;
+            }
+            case constants_1.PROPERTY.IS_DRAGGABLE: {
+                this.rolloverLineAnnotation.isEditable = this.isDraggableProperty;
+                break;
+            }
+        }
+    };
+    VerticalSliceModifier.prototype.calculateXPosition = function () {
+        // will need to recalculate mousepoint.x
+        var xAxis = this.parentSurface.getXAxisById(this.xAxisId);
+        var isVertical = this.isVerticalChart();
+        if (xAxis) {
+            var xCalc = xAxis.getCurrentCoordinateCalculator();
+            // @ts-ignore
+            var x1v = this.rolloverLineAnnotation.getCoordinate(this.x1Property, xCalc, this.xCoordinateModeProperty);
+            if (this.xCoordinateMode === AnnotationBase_1.ECoordinateMode.Relative ||
+                this.xCoordinateMode === AnnotationBase_1.ECoordinateMode.DataValue) {
+                x1v = x1v + (isVertical ? xAxis.viewRect.top : xAxis.viewRect.left);
+            }
+            // pick a y value in the view area
+            var y1v = isVertical
+                ? this.parentSurface.seriesViewRect.width / 2
+                : this.parentSurface.seriesViewRect.height / 2;
+            this.mousePoint = isVertical ? new Point_1.Point(y1v, x1v) : new Point_1.Point(x1v, y1v);
+        }
+    };
+    return VerticalSliceModifier;
+}(RolloverModifier_1.RolloverModifier));
+exports.VerticalSliceModifier = VerticalSliceModifier;

package/Charting/ChartModifiers/constants.d.ts

@@ -24,5 +24,10 @@ export declare enum PROPERTY {
     PLACEMENT_DIV_ID = "PLACEMENT_DIV_ID",
     X_LINE = "X_LINE",
     Y_LINE = "Y_LINE",
-    AXIS_LABELS = "AXIS_LABELS"
+    AXIS_LABELS = "AXIS_LABELS",
+    X1 = "X1",
+    X_COORDINATE_MODE = "X_COORDINATE_MODE",
+    IS_DRAGGABLE = "IS_DRAGGABLE",
+    LINE_ANNOTATIONS_OPTIONS = "LINE_ANNOTATIONS_OPTIONS",
+    LINE_SELECTION_COLOR = "LINE_SELECTION_COLOR"
 }

package/Charting/ChartModifiers/constants.js

@@ -29,4 +29,9 @@ var PROPERTY;
     PROPERTY["X_LINE"] = "X_LINE";
     PROPERTY["Y_LINE"] = "Y_LINE";
     PROPERTY["AXIS_LABELS"] = "AXIS_LABELS";
+    PROPERTY["X1"] = "X1";
+    PROPERTY["X_COORDINATE_MODE"] = "X_COORDINATE_MODE";
+    PROPERTY["IS_DRAGGABLE"] = "IS_DRAGGABLE";
+    PROPERTY["LINE_ANNOTATIONS_OPTIONS"] = "LINE_ANNOTATIONS_OPTIONS";
+    PROPERTY["LINE_SELECTION_COLOR"] = "LINE_SELECTION_COLOR";
 })(PROPERTY = exports.PROPERTY || (exports.PROPERTY = {}));

package/Charting/Drawing/RenderSurface.js

@@ -26,6 +26,7 @@ var RenderSurface = /** @class */ (function () {
             // Don't try and draw in tests
             return;
         }
+        //console.log("Invalidate");
         // Prevent drawing request when WebGL context is lost
         if ((_a = WebGlHelper_1.WebGlHelper.getContext(this.webAssemblyContext.canvas)) === null || _a === void 0 ? void 0 : _a.isContextLost()) {
             return;

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

@@ -275,7 +275,11 @@ export declare abstract class AnnotationBase extends DeletableEntity implements
     private isSelectedProperty;
     private resizeDirectionsProperty;
     private svgAdornerRootProperty;
-    private invalidateState;
+    protected invalidateState: {
+        isHidden: boolean;
+        x1: number;
+        y1: number;
+    };
     /** @inheritDoc */
     get annotationLayer(): EAnnotationLayer;
     /** @inheritDoc */

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

@@ -78,6 +78,8 @@ export declare abstract class SvgAnnotationBase extends AnnotationBase {
      * Gets or sets horizontal anchor point
      */
     set horizontalAnchorPoint(value: EHorizontalAnchorPoint);
+    suspendInvalidate(): void;
+    resumeInvalidate(): void;
     /**
      * Updates the annotation position, with the {@link CoordinateCalculatorBase | Coordinate Calculators} passed in
      * @param xCalc The XAxis {@link CoordinateCalculatorBase | CoordinateCalculator} applied to this annotation

package/Charting/Visuals/Annotations/SvgAnnotationBase.js

@@ -141,6 +141,27 @@ var SvgAnnotationBase = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    SvgAnnotationBase.prototype.suspendInvalidate = function () {
+        _super.prototype.suspendInvalidate.call(this);
+        //@ts-ignore
+        this.invalidateState.xCoordShift = this.xCoordShift;
+        //@ts-ignore
+        this.invalidateState.yCoordShift = this.yCoordShift;
+    };
+    SvgAnnotationBase.prototype.resumeInvalidate = function () {
+        if (!this.invalidateState)
+            return;
+        if (
+        //@ts-ignore
+        this.xCoordShift !== this.invalidateState.xCoordShift ||
+            //@ts-ignore
+            this.yCoordShift !== this.invalidateState.yCoordShift) {
+            if (this.invalidateParentCallback) {
+                this.invalidateParentCallback();
+            }
+        }
+        _super.prototype.resumeInvalidate.call(this);
+    };
     /**
      * Updates the annotation position, with the {@link CoordinateCalculatorBase | Coordinate Calculators} passed in
      * @param xCalc The XAxis {@link CoordinateCalculatorBase | CoordinateCalculator} applied to this annotation

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

@@ -362,6 +362,7 @@ export declare abstract class AxisBase2D extends AxisCore implements IThemeable
     protected webAssemblyContext2D: TSciChart;
     protected axisRendererProperty: AxisRenderer;
     protected autoRangeAnimationProperty: IAutoRangeAnimationOptions;
+    private getlabelStyleProxy;
     private labelStyleProperty;
     private axisAlignmentProperty;
     private isInnerAxisProperty;

package/Charting/Visuals/Axis/AxisBase2D.js

@@ -108,7 +108,18 @@ var AxisBase2D = /** @class */ (function (_super) {
          * Gets the {@link AxisLayoutState} class which manages layout
          */
         _this.axisLayoutState = new AxisLayoutState_1.AxisLayoutState();
-        _this.labelStyleProperty = {
+        _this.getlabelStyleProxy = function (newStyle) {
+            return new Proxy(newStyle, {
+                set: function (target, key, value) {
+                    //@ts-ignore
+                    target[key] = value;
+                    _this.notifyPropertyChanged(constants_1.PROPERTY.TEXT_STYLE);
+                    _this.dpiAdjustedLabelStyleCache = undefined;
+                    return true;
+                }
+            });
+        };
+        _this.labelStyleProperty = _this.getlabelStyleProxy({
             fontSize: 14,
             fontFamily: "Arial",
             color: SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME.tickTextBrush,
@@ -116,7 +127,7 @@ var AxisBase2D = /** @class */ (function (_super) {
             fontStyle: "normal",
             padding: Thickness_1.Thickness.fromString("2 4 2 4"),
             alignment: LabelAlignment_1.ELabelAlignment.Auto
-        };
+        });
         _this.isInnerAxisProperty = false;
         _this.isPrimaryAxisProperty = false;
         _this.axisBorderProperty = {
@@ -151,7 +162,7 @@ var AxisBase2D = /** @class */ (function (_super) {
         _this.zoomExtentsRange = (options === null || options === void 0 ? void 0 : options.zoomExtentsToInitialRange) ? _this.visibleRange : options === null || options === void 0 ? void 0 : options.zoomExtentsRange;
         _this.axisAlignment = (_f = options === null || options === void 0 ? void 0 : options.axisAlignment) !== null && _f !== void 0 ? _f : _this.axisAlignment;
         _this.axisTitle = (_g = options === null || options === void 0 ? void 0 : options.axisTitle) !== null && _g !== void 0 ? _g : _this.axisTitle;
-        _this.labelStyle = __assign(__assign({}, _this.labelStyle), options === null || options === void 0 ? void 0 : options.labelStyle);
+        _this.labelStyle = _this.getlabelStyleProxy(__assign(__assign({}, _this.labelStyle), options === null || options === void 0 ? void 0 : options.labelStyle));
         _this.axisBorder = __assign(__assign({}, _this.axisBorder), options === null || options === void 0 ? void 0 : options.axisBorder);
         _this.isInnerAxis = (_h = options === null || options === void 0 ? void 0 : options.isInnerAxis) !== null && _h !== void 0 ? _h : _this.isInnerAxis;
         _this.stackedAxisLength = (_j = options === null || options === void 0 ? void 0 : options.stackedAxisLength) !== null && _j !== void 0 ? _j : _this.stackedAxisLength;
@@ -514,9 +525,11 @@ var AxisBase2D = /** @class */ (function (_super) {
          * Gets or sets a {@link TTextStyle} object for styling axis labels
          */
         set: function (textStyle) {
-            this.labelStyleProperty = __assign(__assign({}, this.labelStyle), textStyle);
-            this.dpiAdjustedLabelStyleCache = undefined;
+            var newStyle = __assign(__assign({}, this.labelStyle), textStyle);
+            this.labelStyleProperty = this.getlabelStyleProxy(newStyle);
+            // Notify here as well since we are replacing the whole property
             this.notifyPropertyChanged(constants_1.PROPERTY.TEXT_STYLE);
+            this.dpiAdjustedLabelStyleCache = undefined;
         },
         enumerable: false,
         configurable: true

package/Charting/Visuals/RenderableSeries/DataLabels/BaseDataLabelProvider.d.ts

@@ -47,6 +47,7 @@ export declare abstract class BaseDataLabelProvider {
     protected parentSeries: IRenderableSeries;
     protected styleProperty: TDataLabelStyle;
     protected colorProperty: string;
+    private getstyleProxy;
     /**
      * Creates an instance of the {@link DataLabelProvider}
      */

package/Charting/Visuals/RenderableSeries/DataLabels/BaseDataLabelProvider.js

@@ -23,11 +23,22 @@ var BaseDataLabelProvider = /** @class */ (function () {
      * Creates an instance of the {@link DataLabelProvider}
      */
     function BaseDataLabelProvider(options) {
+        var _this = this;
         /**
          * The text to draw, along with the sizes and positions.  Usually generated, but can be updated before final drawing
          */
         this.dataLabels = [];
-        this.styleProperty = options === null || options === void 0 ? void 0 : options.style;
+        this.getstyleProxy = function (newStyle) {
+            return new Proxy(newStyle, {
+                set: function (target, key, value) {
+                    //@ts-ignore
+                    target[key] = value;
+                    _this.invalidateParent();
+                    return true;
+                }
+            });
+        };
+        this.styleProperty = (options === null || options === void 0 ? void 0 : options.style) ? this.getstyleProxy(options === null || options === void 0 ? void 0 : options.style) : undefined;
         this.colorProperty = options === null || options === void 0 ? void 0 : options.color;
     }
     /**
@@ -57,7 +68,7 @@ var BaseDataLabelProvider = /** @class */ (function () {
          * Gets or sets the text style used for data labels. The style must be set, with fontFamily and fontSize set, in order for text to be drawn.
          */
         set: function (value) {
-            this.styleProperty = value;
+            this.styleProperty = this.getstyleProxy(value);
             this.invalidateParent();
         },
         enumerable: false,
@@ -86,7 +97,7 @@ var BaseDataLabelProvider = /** @class */ (function () {
     });
     /** Update the style.  Only the properties passed will be updated */
     BaseDataLabelProvider.prototype.updateStyle = function (value) {
-        this.styleProperty = __assign(__assign({}, this.styleProperty), value);
+        this.styleProperty = this.getstyleProxy(__assign(__assign({}, this.styleProperty), value));
         this.invalidateParent();
     };
     /**

package/Charting/Visuals/RenderableSeries/RolloverModifier/RolloverModifierRenderableSeriesProps.d.ts

@@ -10,6 +10,7 @@ export interface IRolloverModifier {
     tooltipDataTemplate: TRolloverTooltipDataTemplate;
 }
 export declare class RolloverModifierRenderableSeriesProps {
+    static copy(from: RolloverModifierRenderableSeriesProps, to: RolloverModifierRenderableSeriesProps): void;
     tooltip: RolloverTooltipSvgAnnotation;
     marker: RolloverMarkerSvgAnnotation;
     width: number;
@@ -20,6 +21,7 @@ export declare class RolloverModifierRenderableSeriesProps {
     tooltipLegendOffsetX: number;
     tooltipLegendOffsetY: number;
     rolloverModifier: IRolloverModifier;
+    renderableSeries: IRenderableSeries;
     private tooltipLegendTemplateProperty;
     private invalidateParentCallback;
     private showsRolloverProperty;
@@ -28,7 +30,6 @@ export declare class RolloverModifierRenderableSeriesProps {
     private tooltipTitleProperty;
     private markerColorProperty;
     private tooltipDataTemplateProperty?;
-    private renderableSeries;
     private isY1;
     constructor(renderableSeries: IRenderableSeries, isY1?: boolean);
     setInvalidateParentCallback(callback: () => void): void;

package/Charting/Visuals/RenderableSeries/RolloverModifier/RolloverModifierRenderableSeriesProps.js

@@ -14,6 +14,20 @@ var RolloverModifierRenderableSeriesProps = /** @class */ (function () {
         this.renderableSeries = renderableSeries;
         this.isY1 = isY1;
     }
+    RolloverModifierRenderableSeriesProps.copy = function (from, to) {
+        to.markerColorProperty = from.markerColor;
+        to.showsRolloverProperty = from.showRollover;
+        to.tooltipColorProperty = from.tooltipColor;
+        to.tooltipDataTemplateProperty = from.tooltipDataTemplate;
+        to.tooltipLabelX = from.tooltipLabelX;
+        to.tooltipLabelY = from.tooltipLabelY;
+        to.tooltipLegendOffsetX = from.tooltipLegendOffsetX;
+        to.tooltipLegendOffsetY = from.tooltipLegendOffsetY;
+        to.tooltipTemplate = from.tooltipTemplate;
+        to.tooltipTextColorProperty = from.tooltipTextColorProperty;
+        to.tooltipTitleProperty = from.tooltipTitle;
+        to.invalidateParentCallback = from.invalidateParentCallback;
+    };
     RolloverModifierRenderableSeriesProps.prototype.setInvalidateParentCallback = function (callback) {
         this.invalidateParentCallback = callback;
     };

package/Charting/Visuals/SciChartPieSurface/SciChartPieSurface.js

@@ -705,10 +705,13 @@ var SciChartPieSurface = /** @class */ (function (_super) {
     SciChartPieSurface.prototype.drawChart = function (animationProgress) {
         var _this = this;
         if (animationProgress === void 0) { animationProgress = 1; }
+        var totalValue = this.pieSegmentsTotalValue();
+        if (!totalValue) {
+            return;
+        }
         var strokeWidth = 2;
         var strokeColor = this.themeProviderProperty.sciChartBackground;
         var segments = this.pieSegments.asArray();
-        var totalValue = this.pieSegmentsTotalValue();
         var totalOldValue = this.pieSegmentsTotalOldValue();
         var outerRadius = (Math.min(this.calculateViewRectWidth(this.viewRect.width), this.calculateViewRectHeight(this.viewRect.height)) *
             0.8) /
@@ -727,6 +730,9 @@ var SciChartPieSurface = /** @class */ (function (_super) {
         var currentOldValue = 0;
         segments.forEach(function (el, index) {
             var _a;
+            if (el.value === 0) {
+                return;
+            }
             var oldValue = (_a = el.oldValue) !== null && _a !== void 0 ? _a : 0;
             var newFrom = (360 * currentValue) / totalValue - START_ANGLE;
             var newTo = (360 * (currentValue + el.value)) / totalValue - START_ANGLE;

package/Core/BuildStamp.d.ts

@@ -1,4 +1,4 @@
 import { TSciChart } from "../types/TSciChart";
 import { TSciChart3D } from "../types/TSciChart3D";
-export declare const libraryVersion = "3.2.477";
+export declare const libraryVersion = "3.2.481";
 export declare const checkBuildStamp: (wasmContext: TSciChart | TSciChart3D) => boolean;

package/Core/BuildStamp.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkBuildStamp = exports.libraryVersion = void 0;
-var buildStamp = "2023-09-29T00:00:00";
+var buildStamp = "2023-10-05T00:00:00";
 var result;
 // tslint:disable-next-line:no-var-requires
-exports.libraryVersion = "3.2.477";
+exports.libraryVersion = "3.2.481";
 var checkBuildStamp = function (wasmContext) {
     if (result !== undefined)
         return result;