scichart 2.1.2273 → 2.1.2290

package/Builder/buildSeries.d.ts

@@ -35,6 +35,7 @@ import { ESeriesType } from "../types/SeriesType";
 import { EShaderEffectType } from "../types/ShaderEffectType";
 import { TSciChart } from "../types/TSciChart";
 import { TOhlcSeriesData, TSharedDataDefinition, TXySeriesData, TXyySeriesData, TXyzSeriesData } from "./buildDataSeries";
+import { IImpulseRenderableSeries } from "../Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries";
 /** Definition of a pointmarker, comprising a {@link EPointMarkerType} and the relevant options */
 export declare type TPointMarkerDefinition = {
     type: EPointMarkerType.Cross;
@@ -113,6 +114,10 @@ export declare type TSeriesDefinition = {
     type: ESeriesType.ColumnSeries;
     options?: IColumnRenderableSeriesOptions;
     xyData?: TXySeriesData;
+} | {
+    type: ESeriesType.ImpulseSeries;
+    options?: IImpulseRenderableSeries;
+    xyData?: TXySeriesData;
 } | {
     type: ESeriesType.CandlestickSeries;
     options?: ICandlestickRenderableSeriesOptions;

package/Builder/buildSeries.js

@@ -42,6 +42,7 @@ var ShaderEffectType_1 = require("../types/ShaderEffectType");
 var buildDataSeries_1 = require("./buildDataSeries");
 var classFactory_1 = require("./classFactory");
 var chartBuilder_1 = require("./chartBuilder");
+var FastImpulseRenderableSeries_1 = require("../Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries");
 (0, classFactory_1.registerWasmType)(BaseType_1.EBaseType.PointMarker, PointMarkerType_1.EPointMarkerType.Cross, function (wasm, options) { return new CrossPointMarker_1.CrossPointMarker(wasm, options); }, true);
 (0, classFactory_1.registerWasmType)(BaseType_1.EBaseType.PointMarker, PointMarkerType_1.EPointMarkerType.Ellipse, function (wasm, options) { return new EllipsePointMarker_1.EllipsePointMarker(wasm, options); }, true);
 (0, classFactory_1.registerWasmType)(BaseType_1.EBaseType.PointMarker, PointMarkerType_1.EPointMarkerType.Sprite, function (wasm, options) { return new SpritePointMarker_1.SpritePointMarker(wasm, options); }, true);
@@ -93,6 +94,9 @@ var buildSeries = function (wasmContext, definition, sharedData) {
         else if (seriesDef.type === SeriesType_1.ESeriesType.ColumnSeries) {
             series = new FastColumnRenderableSeries_1.FastColumnRenderableSeries(wasmContext, seriesDef.options);
         }
+        else if (seriesDef.type === SeriesType_1.ESeriesType.ImpulseSeries) {
+            series = new FastImpulseRenderableSeries_1.FastImpulseRenderableSeries(wasmContext, seriesDef.options);
+        }
         else if (seriesDef.type === SeriesType_1.ESeriesType.LineSeries) {
             series = new FastLineRenderableSeries_1.FastLineRenderableSeries(wasmContext, seriesDef.options);
         }

package/Charting/Themes/IThemeProvider.d.ts

@@ -204,6 +204,11 @@ export interface IThemeProvider {
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
      */
     columnFillBrush: string;
+    /**
+     * The default {@link FastImpulseRenderableSeries} fill brush as an HTML color code
+     * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
+     */
+    impulseFillBrush?: string;
     /**
      * The default {@link UniformHeatmapRenderableSeries} color-map gradient stops
      */
@@ -487,6 +492,7 @@ export declare abstract class ThemeProvider implements IThemeProvider {
     abstract lineSeriesColor: string;
     abstract columnLineColor: string;
     abstract columnFillBrush: string;
+    abstract impulseFillBrush: string;
     abstract defaultColorMapBrush: TGradientStop[];
     abstract axisTitleColor: string;
     abstract shadowEffectColor: string;

package/Charting/Themes/SciChartJSDarkTheme.d.ts

@@ -111,6 +111,8 @@ export declare class SciChartJSDarkTheme extends ThemeProvider {
     /** @inheritDoc */
     columnFillBrush: string;
     /** @inheritDoc */
+    impulseFillBrush: string;
+    /** @inheritDoc */
     defaultColorMapBrush: {
         offset: number;
         color: string;

package/Charting/Themes/SciChartJSDarkTheme.js

@@ -132,6 +132,8 @@ var SciChartJSDarkTheme = /** @class */ (function (_super) {
         /** @inheritDoc */
         _this.columnFillBrush = "#FFFFFFFF";
         /** @inheritDoc */
+        _this.impulseFillBrush = "#FFFFFFFF";
+        /** @inheritDoc */
         _this.defaultColorMapBrush = [
             { offset: 0, color: "DARKBLUE" },
             { offset: 0.5, color: "CORNFLOWERBLUE" },

package/Charting/Themes/SciChartJSLightTheme.d.ts

@@ -111,6 +111,8 @@ export declare class SciChartJSLightTheme extends ThemeProvider {
     /** @inheritDoc */
     columnFillBrush: string;
     /** @inheritDoc */
+    impulseFillBrush: string;
+    /** @inheritDoc */
     defaultColorMapBrush: {
         offset: number;
         color: string;

package/Charting/Themes/SciChartJSLightTheme.js

@@ -132,6 +132,8 @@ var SciChartJSLightTheme = /** @class */ (function (_super) {
         /** @inheritDoc */
         _this.columnFillBrush = "#777777FF";
         /** @inheritDoc */
+        _this.impulseFillBrush = "#777777FF";
+        /** @inheritDoc */
         _this.defaultColorMapBrush = [
             { offset: 0, color: "DARKBLUE" },
             { offset: 0.5, color: "CORNFLOWERBLUE" },

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

@@ -30,6 +30,7 @@ export declare abstract class CategoryAxisBase extends AxisBase2D {
     private defaultXValuesProperty;
     private defaultXStartProperty;
     private defaultXStepProperty;
+    private defaultBaseXValues;
     /**
      * Creates an instance of a {@link CategoryAxisBase}
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and
@@ -88,4 +89,8 @@ export declare abstract class CategoryAxisBase extends AxisBase2D {
     protected getMaxAutoTicks(): number;
     private generateDefaultXValuesForCategoryAxis;
     private setBaseXValues;
+    /**
+     * @inheritDoc
+     */
+    delete(): void;
 }

package/Charting/Visuals/Axis/CategoryAxisBase.js

@@ -47,6 +47,7 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         _this.defaultXStepProperty = (_c = options === null || options === void 0 ? void 0 : options.defaultXStep) !== null && _c !== void 0 ? _c : _this.defaultXStepProperty;
         _this.tickProvider = new NumericTickProvider_1.NumericTickProvider(_this.webAssemblyContext2D);
         _this.deltaCalculator = new CategoryDeltaCalculator_1.CategoryDeltaCalculator(_this.webAssemblyContext2D);
+        _this.defaultBaseXValues = new _this.webAssemblyContext2D.SCRTDoubleVector();
         return _this;
     }
     Object.defineProperty(CategoryAxisBase.prototype, "isCategoryAxis", {
@@ -178,23 +179,25 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         return Math.min(Math.max(1, this.maxAutoTicks), coordCalc.baseXValues.size());
     };
     CategoryAxisBase.prototype.generateDefaultXValuesForCategoryAxis = function () {
-        var _this = this;
-        var defaultBaseXValues = new this.webAssemblyContext2D.SCRTDoubleVector();
+        this.defaultBaseXValues.clear();
         if (this.defaultXValues && this.defaultXValues.length > 0) {
-            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, defaultBaseXValues, this.defaultXValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, this.defaultBaseXValues, this.defaultXValues);
         }
         else {
-            var length_1 = Math.ceil(this.visibleRange.diff);
-            var xValues = Array.from(Array(length_1), function (_, i) { return _this.defaultXStart + i * _this.defaultXStep; });
-            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, defaultBaseXValues, xValues);
+            var xValues = [];
+            var length_1 = 10;
+            for (var i = 0; i < length_1; i++) {
+                xValues.push(this.defaultXStart + i * this.defaultXStep);
+            }
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, this.defaultBaseXValues, xValues);
         }
-        return defaultBaseXValues;
+        return this.defaultBaseXValues;
     };
     CategoryAxisBase.prototype.setBaseXValues = function (coordCalc, renderableSeries) {
-        if (renderableSeries.type === SeriesType_1.ESeriesType.UniformHeatmapSeries) {
+        if ((renderableSeries === null || renderableSeries === void 0 ? void 0 : renderableSeries.type) === SeriesType_1.ESeriesType.UniformHeatmapSeries) {
             throw Error("Category Axis is not supported for UniformHeatmapRenderableSeries");
         }
-        if (renderableSeries.isStacked) {
+        if (renderableSeries === null || renderableSeries === void 0 ? void 0 : renderableSeries.isStacked) {
             var stackedCollection = renderableSeries;
             if (stackedCollection.size() === 0) {
                 throw Error("BaseStackedCollection should have at least one BaseStackedRenderableSeries");
@@ -217,6 +220,13 @@ var CategoryAxisBase = /** @class */ (function (_super) {
             coordCalc.baseXValues = renderableSeries.dataSeries.getNativeXValues();
         }
     };
+    /**
+     * @inheritDoc
+     */
+    CategoryAxisBase.prototype.delete = function () {
+        _super.prototype.delete.call(this);
+        this.defaultBaseXValues = (0, Deleter_1.deleteSafe)(this.defaultBaseXValues);
+    };
     return CategoryAxisBase;
 }(AxisBase2D_1.AxisBase2D));
 exports.CategoryAxisBase = CategoryAxisBase;

package/Charting/Visuals/RenderableSeries/Animations/animationHelpers.d.ts

@@ -14,7 +14,7 @@ export declare const animationHelpers: {
     checkCanDraw: (animationFSM: AnimationFiniteStateMachine) => boolean;
     checkIsAnimationRunning: (animationQueue: IAnimation[], animationFSM: AnimationFiniteStateMachine) => boolean;
     animationUpdate: (animationFSM: SeriesAnimationFiniteStateMachine, timeElapsed: number, beforeAnimationStart: () => void, afterAnimationComplete: () => void, updateAnimationProperties: (progress: number, animationFSM: SeriesAnimationFiniteStateMachine) => void) => void;
-    createPointMarker: (wasmContext: TSciChart, pointMarkerStyle: BasePointMarkerStyle) => SpritePointMarker | CrossPointMarker | EllipsePointMarker | XPointMarker | SquarePointMarker | TrianglePointMarker;
+    createPointMarker: (wasmContext: TSciChart, pointMarkerStyle: BasePointMarkerStyle) => EllipsePointMarker | SpritePointMarker | CrossPointMarker | XPointMarker | SquarePointMarker | TrianglePointMarker;
     interpolateNumber: (from: number, to: number, progress: number) => number;
     interpolateColor: (from: number, to: number, progress: number) => number;
     copyVector: (sourceVector: SCRTDoubleVector, targetVector: SCRTDoubleVector) => void;

package/Charting/Visuals/RenderableSeries/DrawingProviders/UniformContoursDrawingProvider.js

@@ -85,6 +85,7 @@ var UniformContoursDrawingProvider = /** @class */ (function (_super) {
      * @inheritDoc
      */
     UniformContoursDrawingProvider.prototype.draw = function (renderContext, renderPassData) {
+        var _this = this;
         var _a, _b;
         var heightsTexture = (_a = this.heightsTextureCache) === null || _a === void 0 ? void 0 : _a.value;
         if (heightsTexture) {
@@ -94,15 +95,36 @@ var UniformContoursDrawingProvider = /** @class */ (function (_super) {
             // renderContext.getNativeContext().DrawTexture(this.heightsTexture, 10, 100, 256, 256);
             // renderContext.getNativeContext().DrawTexture(this.paletteTexture.getTexture(), 310, 100, 256, 256);
             // END DEBUG CODE
-            var cParams = this.parentSeries.getContourDrawingParams();
-            var x = renderPassData.xCoordinateCalculator.getCoordinate(cParams.xMin);
-            var y = renderPassData.yCoordinateCalculator.getCoordinate(cParams.yMin);
-            var width = renderPassData.xCoordinateCalculator.getCoordinate(cParams.xMax);
-            var height = renderPassData.yCoordinateCalculator.getCoordinate(cParams.yMax);
-            if (this.parentSeries.minorsPerMajor > 0) {
-                this.drawContours(renderContext, x, y, width, height, cParams.zMin, cParams.zMax, cParams.minorStepZ, cParams.minorLineStyle);
+            var cParams_1 = this.parentSeries.getContourDrawingParams();
+            var isVerticalChart = renderPassData.isVerticalChart;
+            var x_1 = renderPassData.xCoordinateCalculator.getCoordinate(cParams_1.xMin);
+            var y_1 = renderPassData.yCoordinateCalculator.getCoordinate(cParams_1.yMin);
+            var width_1 = renderPassData.xCoordinateCalculator.getCoordinate(cParams_1.xMax);
+            var height_1 = renderPassData.yCoordinateCalculator.getCoordinate(cParams_1.yMax);
+            var textureWidth = Math.abs(x_1 - width_1);
+            var drawContours = function () {
+                if (_this.parentSeries.minorsPerMajor > 0) {
+                    _this.drawContours(renderContext, x_1, y_1, width_1, height_1, cParams_1.zMin, cParams_1.zMax, cParams_1.minorStepZ, cParams_1.minorLineStyle);
+                }
+                _this.drawContours(renderContext, x_1, y_1, width_1, height_1, cParams_1.zMin, cParams_1.zMax, cParams_1.majorStepZ, cParams_1.majorLineStyle);
+            };
+            if (isVerticalChart) {
+                var nativeContext = renderContext.getNativeContext();
+                var hasFlippedXCoordinates = renderPassData.xCoordinateCalculator.hasFlippedCoordinates;
+                nativeContext.PushMatrix();
+                nativeContext.PushState();
+                nativeContext.Rotate(-90);
+                var xTrans = hasFlippedXCoordinates ? -textureWidth - x_1 : -x_1;
+                nativeContext.Translate(xTrans, 0);
+                x_1 = hasFlippedXCoordinates ? textureWidth : 0;
+                width_1 = hasFlippedXCoordinates ? 0 : textureWidth;
+                drawContours();
+                nativeContext.PopMatrix();
+                nativeContext.PopState();
+            }
+            else {
+                drawContours();
             }
-            this.drawContours(renderContext, x, y, width, height, cParams.zMin, cParams.zMax, cParams.majorStepZ, cParams.majorLineStyle);
         }
     };
     UniformContoursDrawingProvider.prototype.drawContours = function (renderContext, x, y, width, height, zMin, zMax, zStep, lineStyle) {

package/Charting/Visuals/RenderableSeries/DrawingProviders/UniformHeatmapDrawingProvider.js

@@ -112,15 +112,19 @@ var UniformHeatmapDrawingProvider = /** @class */ (function (_super) {
             var viewRect = this.parentSeries.parentSurface.seriesViewRect;
             var textureWidth = Math.abs(xMin - xMax);
             if (isVerticalChart) {
+                nativeContext.PushMatrix();
+                nativeContext.PushState();
                 nativeContext.Rotate(-90);
-                var xTrans = hasFlippedXCoordinates ? -viewRect.y - xMin : -textureWidth - viewRect.y - xMin;
-                nativeContext.Translate(xTrans, viewRect.x);
+                var xTrans = hasFlippedXCoordinates ? -xMin : -textureWidth - xMin;
+                nativeContext.Translate(xTrans, 0);
                 var x = hasFlippedXCoordinates ? 0 : textureWidth;
                 var width = hasFlippedXCoordinates ? textureWidth : 0;
                 var y = yMin;
                 var height = yMax;
                 this.drawHeatmap(nativeContext, x, y, width, height);
                 // Maybe to use nativeContext.Scale(-1, 1);???
+                nativeContext.PopMatrix();
+                nativeContext.PopState();
             }
             else {
                 this.drawHeatmap(nativeContext, xMin, yMin, xMax, yMax);

package/Charting/Visuals/RenderableSeries/FastColumnRenderableSeries.d.ts

@@ -45,7 +45,7 @@ export interface IColumnRenderableSeriesOptions extends IBaseRenderableSeriesOpt
  */
 export declare class FastColumnRenderableSeries extends BaseRenderableSeries {
     /** @inheritDoc */
-    readonly type = ESeriesType.ColumnSeries;
+    readonly type: ESeriesType;
     private fillProperty;
     private zeroLineYProperty;
     private dataPointWidthProperty;

package/Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries.d.ts

@@ -0,0 +1,84 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { ESeriesType } from "../../../types/SeriesType";
+import { TSciChart } from "../../../types/TSciChart";
+import { IThemeProvider } from "../../Themes/IThemeProvider";
+import { FastColumnRenderableSeries } from "./FastColumnRenderableSeries";
+import { IHitTestProvider } from "./HitTest/IHitTestProvider";
+import { IBaseRenderableSeriesOptions } from "./IBaseRenderableSeriesOptions";
+/**
+ * Options to pass to the {@link FastImpulseRenderableSeries} constructor
+ */
+export interface IImpulseRenderableSeries extends IBaseRenderableSeriesOptions {
+    /**
+     * The impulse fill as an HTML color code
+     */
+    fill?: string;
+    /**
+     * The impulse point size as a number value
+     */
+    size?: number;
+    /**
+     * Gets or sets the Zero-line Y, the Y-value where the column crosses zero and inverts. Default is 0
+     */
+    zeroLineY?: number;
+}
+/**
+ * Defines a impulse-series or JavaScript impulse chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * To add a impulse series to a {@link SciChartSurface} you need to declare both the {@link FastImpulseRenderableSeries | RenderableSeries}
+ * and a {@link XyDataSeries | DataSeries}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChartSurface: SciChartSurface;
+ * const wasmContext: TSciChart;
+ * // Create and fill the dataseries
+ * const dataSeries = new XyDataSeries(wasmContext);
+ * dataSeries.append(1,2);
+ * dataSeries.append(1,2);
+ * // Create the renderableSeries
+ * const impulseSeries = new FastImpulseRenderableSeries(wasmContext);
+ * impulseSeries.dataSeries = dataSeries;
+ * // append to the SciChartSurface
+ * sciChartSurface.renderableSeries.add(impulseSeries);
+ * ```
+ */
+export declare class FastImpulseRenderableSeries extends FastColumnRenderableSeries {
+    /** @inheritDoc */
+    readonly type = ESeriesType.ImpulseSeries;
+    private impulseFillProperty;
+    private impulseSizeProperty;
+    private impulseDataPointWidthProperty;
+    private impulseStrokeThicknessProperty;
+    /**
+     * Creates an instance of the {@link FastImpulseRenderableSeries}
+     * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options optional parameters of type {@link IImpulseRenderableSeries} applied when constructing the series type
+     */
+    constructor(webAssemblyContext: TSciChart, options?: IImpulseRenderableSeries);
+    /**
+     * Gets or sets the color of each impulse
+     */
+    get fill(): string;
+    set fill(htmlColorCode: string);
+    /**
+     * Gets or sets the size of each impulse point
+     */
+    get size(): number;
+    set size(sizeParam: number);
+    /**
+     * @inheritDoc
+     */
+    getXRange(): NumberRange;
+    /**
+     * @inheritDoc
+     */
+    getYRange(xVisibleRange: NumberRange, isXCategoryAxis?: boolean): NumberRange;
+    /** @inheritDoc */
+    toJSON(excludeData?: boolean): import("../../../Builder/buildSeries").TSeriesDefinition;
+    /** @inheritDoc */
+    applyTheme(themeProvider: IThemeProvider): void;
+    /** @inheritDoc */
+    protected newHitTestProvider(): IHitTestProvider;
+}

package/Charting/Visuals/RenderableSeries/FastImpulseRenderableSeries.js

@@ -0,0 +1,179 @@
+"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.FastImpulseRenderableSeries = void 0;
+var NumberRange_1 = require("../../../Core/NumberRange");
+var SeriesType_1 = require("../../../types/SeriesType");
+var EllipsePointMarker_1 = require("../PointMarkers/EllipsePointMarker");
+var SciChartSurfaceBase_1 = require("../SciChartSurfaceBase");
+var DpiHelper_1 = require("../TextureManager/DpiHelper");
+var constants_1 = require("./constants");
+var FastColumnRenderableSeries_1 = require("./FastColumnRenderableSeries");
+var ImpulseSeriesHitTestProvider_1 = require("./HitTest/ImpulseSeriesHitTestProvider");
+/**
+ * Defines a impulse-series or JavaScript impulse chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * To add a impulse series to a {@link SciChartSurface} you need to declare both the {@link FastImpulseRenderableSeries | RenderableSeries}
+ * and a {@link XyDataSeries | DataSeries}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChartSurface: SciChartSurface;
+ * const wasmContext: TSciChart;
+ * // Create and fill the dataseries
+ * const dataSeries = new XyDataSeries(wasmContext);
+ * dataSeries.append(1,2);
+ * dataSeries.append(1,2);
+ * // Create the renderableSeries
+ * const impulseSeries = new FastImpulseRenderableSeries(wasmContext);
+ * impulseSeries.dataSeries = dataSeries;
+ * // append to the SciChartSurface
+ * sciChartSurface.renderableSeries.add(impulseSeries);
+ * ```
+ */
+var FastImpulseRenderableSeries = /** @class */ (function (_super) {
+    __extends(FastImpulseRenderableSeries, _super);
+    /**
+     * Creates an instance of the {@link FastImpulseRenderableSeries}
+     * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options optional parameters of type {@link IImpulseRenderableSeries} applied when constructing the series type
+     */
+    function FastImpulseRenderableSeries(webAssemblyContext, options) {
+        var _a, _b, _c, _d;
+        var _this = _super.call(this, webAssemblyContext, options) || this;
+        /** @inheritDoc */
+        _this.type = SeriesType_1.ESeriesType.ImpulseSeries;
+        _this.impulseFillProperty = SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME.impulseFillBrush;
+        _this.impulseSizeProperty = 10;
+        _this.impulseDataPointWidthProperty = 0;
+        _this.impulseStrokeThicknessProperty = 1;
+        _this.strokeThickness = (_a = options === null || options === void 0 ? void 0 : options.strokeThickness) !== null && _a !== void 0 ? _a : _this.impulseStrokeThicknessProperty;
+        _this.fill = (_b = options === null || options === void 0 ? void 0 : options.fill) !== null && _b !== void 0 ? _b : _this.impulseFillProperty;
+        _this.size = (_c = options === null || options === void 0 ? void 0 : options.size) !== null && _c !== void 0 ? _c : _this.impulseSizeProperty;
+        _this.stroke = (_d = options === null || options === void 0 ? void 0 : options.fill) !== null && _d !== void 0 ? _d : _this.impulseFillProperty;
+        _this.dataPointWidth = _this.impulseDataPointWidthProperty;
+        if (!(options === null || options === void 0 ? void 0 : options.pointMarker)) {
+            _this.pointMarker = new EllipsePointMarker_1.EllipsePointMarker(webAssemblyContext, {
+                width: _this.impulseSizeProperty,
+                height: _this.impulseSizeProperty,
+                fill: _this.fill,
+                stroke: _this.fill
+            });
+        }
+        return _this;
+    }
+    Object.defineProperty(FastImpulseRenderableSeries.prototype, "fill", {
+        /**
+         * Gets or sets the color of each impulse
+         */
+        get: function () {
+            return this.impulseFillProperty;
+        },
+        set: function (htmlColorCode) {
+            this.impulseFillProperty = htmlColorCode;
+            this.stroke = htmlColorCode;
+            if (this.pointMarker) {
+                this.pointMarker.fill = htmlColorCode;
+                this.pointMarker.stroke = htmlColorCode;
+            }
+            if (this.impulseFillProperty !== htmlColorCode) {
+                this.notifyPropertyChanged(constants_1.PROPERTY.STROKE);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FastImpulseRenderableSeries.prototype, "size", {
+        /**
+         * Gets or sets the size of each impulse point
+         */
+        get: function () {
+            return this.impulseSizeProperty;
+        },
+        set: function (sizeParam) {
+            this.impulseSizeProperty = sizeParam;
+            if (this.pointMarker) {
+                this.pointMarker.width = sizeParam;
+                this.pointMarker.height = sizeParam;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @inheritDoc
+     */
+    FastImpulseRenderableSeries.prototype.getXRange = function () {
+        var range = _super.prototype.getXRange.call(this);
+        var delta = getDelta({
+            pointSize: this.size,
+            areaSize: this.parentSurface.seriesViewRect.width,
+            range: range
+        });
+        return new NumberRange_1.NumberRange(range.min - delta, range.max + delta);
+    };
+    /**
+     * @inheritDoc
+     */
+    FastImpulseRenderableSeries.prototype.getYRange = function (xVisibleRange, isXCategoryAxis) {
+        if (isXCategoryAxis === void 0) { isXCategoryAxis = false; }
+        var yRange = _super.prototype.getYRange.call(this, xVisibleRange, isXCategoryAxis);
+        if (!yRange) {
+            return undefined;
+        }
+        var delta = getDelta({
+            pointSize: this.size,
+            areaSize: this.parentSurface.seriesViewRect.height,
+            range: yRange
+        });
+        return new NumberRange_1.NumberRange(yRange.min - delta, yRange.max + delta);
+    };
+    /** @inheritDoc */
+    FastImpulseRenderableSeries.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var json = _super.prototype.toJSON.call(this, excludeData);
+        var options = {
+            fill: this.fill,
+            size: this.size,
+            zeroLineY: this.zeroLineY
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    /** @inheritDoc */
+    FastImpulseRenderableSeries.prototype.applyTheme = function (themeProvider) {
+        _super.prototype.applyTheme.call(this, themeProvider);
+        var previousThemeProvider = this.parentSurface.previousThemeProvider;
+        if (this.fill === previousThemeProvider.impulseFillBrush) {
+            this.fill = themeProvider.impulseFillBrush;
+        }
+    };
+    /** @inheritDoc */
+    FastImpulseRenderableSeries.prototype.newHitTestProvider = function () {
+        return new ImpulseSeriesHitTestProvider_1.ImpulseSeriesHitTestProvider(this, this.webAssemblyContext);
+    };
+    return FastImpulseRenderableSeries;
+}(FastColumnRenderableSeries_1.FastColumnRenderableSeries));
+exports.FastImpulseRenderableSeries = FastImpulseRenderableSeries;
+/** @ignore */
+var getDelta = function (_a) {
+    var pointSize = _a.pointSize, areaSize = _a.areaSize, range = _a.range;
+    var pointScaled = pointSize * DpiHelper_1.DpiHelper.PIXEL_RATIO;
+    var k = areaSize / (areaSize - pointScaled);
+    return (Math.abs(range.max - range.min) * (k - 1)) / 2;
+};

package/Charting/Visuals/RenderableSeries/HitTest/ImpulseSeriesHitTestProvider.d.ts

@@ -0,0 +1,20 @@
+import { FastImpulseRenderableSeries } from "../FastImpulseRenderableSeries";
+import { BaseHitTestProvider } from "./BaseHitTestProvider";
+import { HitTestInfo } from "./HitTestInfo";
+/**
+ * Hit-test provider for {@link FastColumnRenderableSeries}. See base class {@link BaseHitTestProvider} for further info
+ */
+export declare class ImpulseSeriesHitTestProvider extends BaseHitTestProvider<FastImpulseRenderableSeries> {
+    /**
+     * @inheritDoc
+     */
+    hitTest(x: number, y: number, hitTestRadius?: number): HitTestInfo;
+    /**
+     * @inheritDoc
+     */
+    hitTestForDataPointSelectionModifier(x: number, y: number, hitTestRadius?: number): HitTestInfo;
+    /**
+     * @inheritDoc
+     */
+    hitTestXSlice(x: number, y: number): HitTestInfo;
+}